home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / xshogi11.lha / xshogi-1.1 / xshogi.c < prev    next >
C/C++ Source or Header  |  1993-04-28  |  144KB  |  5,296 lines
  1.  
  2. #define XBOARD_VERSION "2.0"
  3.  
  4. #include <stdio.h>
  5. #include <ctype.h>
  6. #include <signal.h>
  7. #include <sys/ioctl.h>
  8. #include <time.h>
  9. #ifdef HAS_GETTIMEOFDAY
  10. #ifndef ESIX
  11. #include <sys/time.h>
  12. #endif
  13. #endif
  14. #ifdef    __STDC__
  15. #ifndef ESIX
  16. #ifndef apollo
  17. #include <stdlib.h>
  18. #endif 
  19. #endif
  20. #endif
  21. #if    SYSTEM_FIVE || SYSV
  22. #include <sys/types.h>
  23. #include <sys/stat.h>
  24. #ifdef    AIXV3
  25. #include <fcntl.h>
  26. #else
  27. #include <sys/fcntl.h>
  28. #endif AIXV3
  29. #if    SVR4
  30. #include <stropts.h>
  31. #endif
  32. #endif
  33. #if defined(__STDC__) || SYSTEM_FIVE || SYSV
  34. #include <string.h>
  35. #else
  36. #include <strings.h>
  37. #endif
  38. #include <pwd.h>
  39.  
  40. #ifdef IRIS
  41. #include <sys/sysmacros.h>
  42. #endif
  43.  
  44. #include <X11/Intrinsic.h>
  45. #include <X11/StringDefs.h>
  46. #include <X11/Shell.h>
  47. #include <X11/Xaw/Dialog.h>
  48. #include <X11/Xaw/Form.h>
  49. #include <X11/Xaw/List.h>
  50. #include <X11/Xaw/Label.h>
  51. #include <X11/Xaw/SimpleMenu.h>
  52. #include <X11/Xaw/SmeBSB.h>
  53. #include <X11/Xaw/SmeLine.h>
  54. #include <X11/cursorfont.h>
  55.  
  56. #include "version.h"
  57. #include "xshogi.h"
  58.  
  59.  
  60. #include "eastern_bitmaps/icon.xbm"
  61.  
  62. #include "eastern_bitmaps/bigsolid.xbm"
  63. #include "eastern_bitmaps/smallsolid.xbm"
  64. #include "eastern_bitmaps/bigsolidR.xbm"
  65. #include "eastern_bitmaps/smallsolidR.xbm"
  66.  
  67. #ifdef WESTERN_BITMAPS
  68.  
  69. #include "western_bitmaps/none.xbm"
  70.  
  71. #include "western_bitmaps/king.xbm"
  72. #include "western_bitmaps/rook.xbm"
  73. #include "western_bitmaps/rookP.xbm"
  74. #include "western_bitmaps/bishop.xbm"
  75. #include "western_bitmaps/bishopP.xbm"
  76. #include "western_bitmaps/gold.xbm"
  77. #include "western_bitmaps/silver.xbm"
  78. #include "western_bitmaps/silverP.xbm"
  79. #include "western_bitmaps/knight.xbm"
  80. #include "western_bitmaps/knightP.xbm"
  81. #include "western_bitmaps/lance.xbm"
  82. #include "western_bitmaps/lanceP.xbm"
  83. #include "western_bitmaps/pawn.xbm"
  84. #include "western_bitmaps/pawnP.xbm"
  85.  
  86. #include "western_bitmaps/kingR.xbm"
  87. #include "western_bitmaps/rookR.xbm"
  88. #include "western_bitmaps/rookPR.xbm"
  89. #include "western_bitmaps/bishopR.xbm"
  90. #include "western_bitmaps/bishopPR.xbm"
  91. #include "western_bitmaps/goldR.xbm"
  92. #include "western_bitmaps/silverR.xbm"
  93. #include "western_bitmaps/silverPR.xbm"
  94. #include "western_bitmaps/knightR.xbm"
  95. #include "western_bitmaps/knightPR.xbm"
  96. #include "western_bitmaps/lanceR.xbm"
  97. #include "western_bitmaps/lancePR.xbm"
  98. #include "western_bitmaps/pawnR.xbm"
  99. #include "western_bitmaps/pawnPR.xbm"
  100.  
  101. #else
  102.  
  103. #include "eastern_bitmaps/none.xbm"
  104.  
  105. #include "eastern_bitmaps/king.xbm"
  106. #include "eastern_bitmaps/rook.xbm"
  107. #include "eastern_bitmaps/rookP.xbm"
  108. #include "eastern_bitmaps/bishop.xbm"
  109. #include "eastern_bitmaps/bishopP.xbm"
  110. #include "eastern_bitmaps/gold.xbm"
  111. #include "eastern_bitmaps/silver.xbm"
  112. #include "eastern_bitmaps/silverP.xbm"
  113. #include "eastern_bitmaps/knight.xbm"
  114. #include "eastern_bitmaps/knightP.xbm"
  115. #include "eastern_bitmaps/lance.xbm"
  116. #include "eastern_bitmaps/lanceP.xbm"
  117. #include "eastern_bitmaps/pawn.xbm"
  118. #include "eastern_bitmaps/pawnP.xbm"
  119.  
  120. #include "eastern_bitmaps/kingR.xbm"
  121. #include "eastern_bitmaps/rookR.xbm"
  122. #include "eastern_bitmaps/rookPR.xbm"
  123. #include "eastern_bitmaps/bishopR.xbm"
  124. #include "eastern_bitmaps/bishopPR.xbm"
  125. #include "eastern_bitmaps/goldR.xbm"
  126. #include "eastern_bitmaps/silverR.xbm"
  127. #include "eastern_bitmaps/silverPR.xbm"
  128. #include "eastern_bitmaps/knightR.xbm"
  129. #include "eastern_bitmaps/knightPR.xbm"
  130. #include "eastern_bitmaps/lanceR.xbm"
  131. #include "eastern_bitmaps/lancePR.xbm"
  132. #include "eastern_bitmaps/pawnR.xbm"
  133. #include "eastern_bitmaps/pawnPR.xbm"
  134.  
  135. #include "eastern_bitmaps/none_m.xbm"
  136.  
  137. #include "eastern_bitmaps/bigsolid_m.xbm"
  138. #include "eastern_bitmaps/smallsolid_m.xbm"
  139. #include "eastern_bitmaps/bigsolidR_m.xbm"
  140. #include "eastern_bitmaps/smallsolidR_m.xbm"
  141.  
  142. #include "eastern_bitmaps/king_m.xbm"
  143. #include "eastern_bitmaps/rook_m.xbm"
  144. #include "eastern_bitmaps/rookP_m.xbm"
  145. #include "eastern_bitmaps/bishop_m.xbm"
  146. #include "eastern_bitmaps/bishopP_m.xbm"
  147. #include "eastern_bitmaps/gold_m.xbm"
  148. #include "eastern_bitmaps/silver_m.xbm"
  149. #include "eastern_bitmaps/silverP_m.xbm"
  150. #include "eastern_bitmaps/knight_m.xbm"
  151. #include "eastern_bitmaps/knightP_m.xbm"
  152. #include "eastern_bitmaps/lance_m.xbm"
  153. #include "eastern_bitmaps/lanceP_m.xbm"
  154. #include "eastern_bitmaps/pawn_m.xbm"
  155. #include "eastern_bitmaps/pawnP_m.xbm"
  156.  
  157. #include "eastern_bitmaps/kingR_m.xbm"
  158. #include "eastern_bitmaps/rookR_m.xbm"
  159. #include "eastern_bitmaps/rookPR_m.xbm"
  160. #include "eastern_bitmaps/bishopR_m.xbm"
  161. #include "eastern_bitmaps/bishopPR_m.xbm"
  162. #include "eastern_bitmaps/goldR_m.xbm"
  163. #include "eastern_bitmaps/silverR_m.xbm"
  164. #include "eastern_bitmaps/silverPR_m.xbm"
  165. #include "eastern_bitmaps/knightR_m.xbm"
  166. #include "eastern_bitmaps/knightPR_m.xbm"
  167. #include "eastern_bitmaps/lanceR_m.xbm"
  168. #include "eastern_bitmaps/lancePR_m.xbm"
  169. #include "eastern_bitmaps/pawnR_m.xbm"
  170. #include "eastern_bitmaps/pawnPR_m.xbm"
  171.  
  172. #include "eastern_bitmaps/none_l.xbm"
  173.  
  174. #include "eastern_bitmaps/bigsolid_l.xbm"
  175. #include "eastern_bitmaps/smallsolid_l.xbm"
  176. #include "eastern_bitmaps/bigsolidR_l.xbm"
  177. #include "eastern_bitmaps/smallsolidR_l.xbm"
  178.  
  179. #include "eastern_bitmaps/king_l.xbm"
  180. #include "eastern_bitmaps/rook_l.xbm"
  181. #include "eastern_bitmaps/rookP_l.xbm"
  182. #include "eastern_bitmaps/bishop_l.xbm"
  183. #include "eastern_bitmaps/bishopP_l.xbm"
  184. #include "eastern_bitmaps/gold_l.xbm"
  185. #include "eastern_bitmaps/silver_l.xbm"
  186. #include "eastern_bitmaps/silverP_l.xbm"
  187. #include "eastern_bitmaps/knight_l.xbm"
  188. #include "eastern_bitmaps/knightP_l.xbm"
  189. #include "eastern_bitmaps/lance_l.xbm"
  190. #include "eastern_bitmaps/lanceP_l.xbm"
  191. #include "eastern_bitmaps/pawn_l.xbm"
  192. #include "eastern_bitmaps/pawnP_l.xbm"
  193.  
  194. #include "eastern_bitmaps/kingR_l.xbm"
  195. #include "eastern_bitmaps/rookR_l.xbm"
  196. #include "eastern_bitmaps/rookPR_l.xbm"
  197. #include "eastern_bitmaps/bishopR_l.xbm"
  198. #include "eastern_bitmaps/bishopPR_l.xbm"
  199. #include "eastern_bitmaps/goldR_l.xbm"
  200. #include "eastern_bitmaps/silverR_l.xbm"
  201. #include "eastern_bitmaps/silverPR_l.xbm"
  202. #include "eastern_bitmaps/knightR_l.xbm"
  203. #include "eastern_bitmaps/knightPR_l.xbm"
  204. #include "eastern_bitmaps/lanceR_l.xbm"
  205. #include "eastern_bitmaps/lancePR_l.xbm"
  206. #include "eastern_bitmaps/pawnR_l.xbm"
  207. #include "eastern_bitmaps/pawnPR_l.xbm"
  208.  
  209. #endif
  210.  
  211. void main P((int argc, char **argv));
  212. void CreateGCs P((void));
  213. void CreatePieces P((void));
  214. void CreatePieceMenus P((void));
  215. void PieceMenuPopup P((Widget w, XEvent *event, String *params,
  216.             Cardinal *num_params));
  217. static void PieceMenuSelect P((Widget w, ChessSquare piece, caddr_t junk));
  218. static void SetBlackToPlay P((void));
  219. static void SetWhiteToPlay P((void));
  220. void ReadBitmap P((String name, Pixmap *pm, Pixmap *qm,
  221.     char small_bits[], char medium_bits[], char large_bits[]));
  222. void CreateGrid P((void));
  223. int EventToSquare P((int x));
  224. int EventToXSquare P((int x));
  225. ChessSquare CharToPiece P((int c, int p));
  226. void DrawSquare P((int row, int column, ChessSquare piece));
  227. void BlinkSquare P((int row, int column, ChessSquare piece));
  228. void EventProc P((Widget widget, caddr_t unused, XEvent *event));
  229. void DrawPosition P((Widget w, XExposeEvent *event));
  230. void InitPosition P((void));
  231. void CopyBoard P((Board to, Board from));
  232. void CopyCatches P((Catched to, Catched from));
  233. void ClearCatches P((Catched to));
  234. void UpdateCatched P((int c, int f, int d, int a, int cm));
  235. void SendCurrentBoard P((FILE *fp));
  236. void SendBoard P((FILE *fp, Board board, Catched catches));
  237. void HandleUserMove P((Widget w, XEvent *event));
  238. void FinishUserMove P((ChessMove move_type, int to_x, int to_y));
  239. void HandleMachineMove P((char *message, FILE *fp));
  240. void ReadGameFile P((void));
  241. int ReadGameFileProc P((void));
  242. void MakeMove P((ChessMove *move_type, int from_x, int from_y,
  243.     int to_x, int to_y));
  244. void InitChessProgram P((char *host_name, char *program_name, int *pid,
  245.     FILE **to, FILE **from, XtIntervalId *xid));
  246. void ShutdownChessPrograms P((char *message));
  247. void CommentPopUp P((char *label));
  248. void FileNamePopUp P((char *label, void (*proc)(char *name)));
  249. void FileNameCallback P((Widget w, XtPointer client_data,
  250.              XtPointer call_data));
  251. void FileNameAction P((Widget w, XEvent *event));
  252. void PromotionPopUp P((ChessSquare piece, int to_x, int to_y));
  253. void PromotionCallback P((Widget w, XtPointer client_data,
  254.               XtPointer call_data));
  255. void FileModePopUp P((char *name));
  256. void FileModeCallback P((Widget w, XtPointer client_data,
  257.               XtPointer call_data));
  258. void SelectCommand P((Widget w, XtPointer client_data, XtPointer call_data));
  259. void ModeHighlight P((void));
  260. void GameProc P((void));
  261. void QuitProc P((void));
  262. int PlayFromGameFileProc P((char *name));
  263. void MachinePlaysWhiteProc P((void));
  264. void ForwardProc P((void));
  265. void ResetFileProc P((void));
  266. void ResetProc P((void));
  267. int SetupPositionFromFileProc P((char *name));
  268. void MachinePlaysBlackProc P((void));
  269. void BackwardProc P((void));
  270. void FlipProc P((void));
  271. void SaveGameProc P((char *name));
  272. void SwitchProc P((void));
  273. void EditPositionProc P((void));
  274. void EditPositionDone P((void));
  275. void ForceProc P((void));
  276. void HintProc P((void));
  277. void SavePositionProc P((char *name));
  278. void TwoMachinesPlayProc P((void));
  279. void PauseProc P((void));
  280. void Iconify P((void));
  281. void SendToProgram P((char *message, FILE *fp));
  282. void ReceiveFromProgram P((FILE *fp, int *source, XtInputId *id));
  283. void SendSearchDepth P((FILE *fp));
  284. void DisplayMessage P((char *message));
  285. void DisplayName P((char *name));
  286. void Attention P((int pid));
  287. void DisplayClocks P((int clock_mode));
  288. void DisplayTimerLabel P((Widget w, char *color, long timer));
  289. char *TimeString P((long tm));
  290. void Usage P((void));
  291. char *StrStr P((char *string, char *match));
  292. int StrCaseCmp P((char *s1, char *s2));
  293. int ToLower P((int c));
  294. int ToUpper P((int c));
  295. #if    SYSTEM_FIVE || SYSV
  296. char *PseudoTTY P((int *ptyv));
  297. #else
  298. void CatchPipeSignal P((int dummy));
  299. #endif
  300. #define off_board(x) (x < 2 || x > BOARD_SIZE+1)
  301. extern void parseGameFile P((void));
  302.  
  303. /*
  304.  * XShogi depends on Xt R4 or higher
  305.  */
  306. int xtVersion = XtSpecificationRelease;
  307.  
  308. int xScreen;
  309. Display *xDisplay;
  310. Window xBoardWindow;
  311. GC lightSquareGC, darkSquareGC, lineGC, wdPieceGC, wlPieceGC,
  312.     bdPieceGC, blPieceGC, wbPieceGC, bwPieceGC, coordGC,
  313.     charPieceGC, dropPiece;
  314. Pixmap reversePawnBitmap, reverseLanceBitmap, reverseKnightBitmap, reverseSilverBitmap,
  315.        reverseGoldBitmap, reverseBishopBitmap, reverseRookBitmap,
  316.        reversePPawnBitmap, reversePLanceBitmap, reversePKnightBitmap,
  317.        reversePSilverBitmap, reversePBishopBitmap, reversePRookBitmap, 
  318.        reverseKingBitmap, 
  319.        reverseBigSolidBitmap, reverseSmallSolidBitmap,
  320.        normalBigSolidBitmap, normalSmallSolidBitmap,
  321.        normalPawnBitmap, normalLanceBitmap, normalKnightBitmap, 
  322.        normalSilverBitmap, normalGoldBitmap, 
  323.        normalBishopBitmap, normalRookBitmap,
  324.        normalPPawnBitmap, normalPLanceBitmap, normalPKnightBitmap,
  325.        normalPSilverBitmap, normalPBishopBitmap, normalPRookBitmap,
  326.        normalKingBitmap, iconPixmap;  
  327. Widget shellWidget, formWidget, boardWidget, commandsWidget, messageWidget,
  328.     blackTimerWidget, whiteTimerWidget, nameWidget, widgetList[6], 
  329.         commentShell, promotionShell, blackPieceMenu, whitePieceMenu,
  330.     filemodeShell;
  331. XSegment gridSegments[(BOARD_SIZE + 1) * 2];
  332. XtIntervalId firstProgramXID = 0, secondProgramXID = 0,
  333.     readGameXID = 0, timerXID = 0, blinkSquareXID = 0;
  334. XFontStruct *labelFont, *coordFont;
  335. XtAppContext appContext;
  336. void (*fileProc) P((char *name));
  337.  
  338. FILE *fromFirstProgFP, *toFirstProgFP, *fromSecondProgFP,
  339.     *toSecondProgFP, *gameFileFP, *lastMsgFP;
  340. int currentMove = 0, forwardMostMove = 0, firstProgramPID = 0,
  341.     secondProgramPID = 0, squareSize = SMALL_SQUARE_SIZE, fromX = -1,
  342.     fromY = -1, firstMove = True, flipView = False,
  343.     xshogiDebug = True, commentUp = False, filenameUp = False,
  344.         whitePlaysFirst = False, startedFromSetupPosition = False,
  345.     promotionUp = False, searchTime = 0, pmFromX = -1, pmFromY = -1,
  346.         blackFlag = False, whiteFlag = False, maybeThinking = False,
  347.     filemodeUp = False;
  348. Pixel timerForegroundPixel, timerBackgroundPixel;
  349. MatchMode matchMode = MatchFalse;
  350. GameMode gameMode = BeginningOfGame, lastGameMode = BeginningOfGame;
  351. BoardSize boardSize = Small;
  352. char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2],
  353.     ptyname[24], *chessDir, *programName;
  354.  
  355. long blackTimeRemaining, whiteTimeRemaining, timeControl;
  356. extern char currentMoveString[];
  357.  
  358. int black_pixel_is_zero;
  359.                      
  360. Catched catches[MAX_MOVES];
  361.  
  362.  
  363. #define pawn 0
  364. #define lance 1
  365. #define knight 2
  366. #define silver 3
  367. #define gold 4
  368. #define bishop 5
  369. #define rook 6
  370. #define king 7
  371. #define no_piece 8
  372.                        
  373.  
  374. char catchedIndexToChar[8] = {
  375.   'P', 'L', 'N', 'S', 'G', 'B', 'R', 'K'
  376. };
  377.  
  378. ChessSquare catchedIndexToPiece[2][8] = {
  379.    BlackPawn, BlackLance, BlackKnight, BlackSilver, BlackGold,
  380.    BlackBishop, BlackRook, BlackKing,
  381.    WhitePawn, WhiteLance, WhiteKnight, WhiteSilver, WhiteGold,
  382.    WhiteBishop, WhiteRook, WhiteKing
  383. };
  384.  
  385.  
  386. pieceToCatchedIndex[] = {
  387.    pawn, lance, knight, silver, gold, bishop, rook,
  388.    pawn, lance, knight, silver, bishop, rook, king,
  389.    pawn, lance, knight, silver, gold, bishop, rook,
  390.    pawn, lance, knight, silver, bishop, rook, king,
  391.    no_piece
  392. };
  393.  
  394.  
  395.  
  396. Board boards[MAX_MOVES], initialPosition = {
  397.     { BlackLance, BlackKnight, BlackSilver, BlackGold, BlackKing,
  398.               BlackGold, BlackSilver, BlackKnight, BlackLance },
  399.         { EmptySquare, BlackBishop, EmptySquare, EmptySquare, EmptySquare,
  400.               EmptySquare, EmptySquare, BlackRook, EmptySquare }, 
  401.         { BlackPawn, BlackPawn, BlackPawn, BlackPawn, BlackPawn, 
  402.               BlackPawn, BlackPawn, BlackPawn, BlackPawn },
  403.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare, EmptySquare, 
  404.         EmptySquare, EmptySquare, EmptySquare, EmptySquare } ,  
  405.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare, EmptySquare, 
  406.         EmptySquare, EmptySquare, EmptySquare, EmptySquare } ,  
  407.     { EmptySquare, EmptySquare, EmptySquare, EmptySquare, EmptySquare, 
  408.         EmptySquare, EmptySquare, EmptySquare, EmptySquare } ,  
  409.         { WhitePawn, WhitePawn, WhitePawn, WhitePawn, WhitePawn, 
  410.         WhitePawn, WhitePawn, WhitePawn, WhitePawn },
  411.         { EmptySquare, WhiteRook, EmptySquare, EmptySquare, EmptySquare,
  412.               EmptySquare, EmptySquare, WhiteBishop, EmptySquare }, 
  413.     { WhiteLance, WhiteKnight, WhiteSilver, WhiteGold, WhiteKing,
  414.               WhiteGold, WhiteSilver, WhiteKnight, WhiteLance }
  415. };
  416.  
  417. String buttonStrings[] = {
  418.     "Quit", "Load Game", "Machine White", "Forward",
  419.     "Reset", "Load Position", "Machine Black", "Backward",
  420.     "Flip View", "Save Game", "Force Moves", "Pause",
  421.     "Hint", "Save Position", "Two Machines", "Edit Position"
  422. };
  423. /* must be in same order as buttonStrings! */
  424. typedef enum {
  425.     ButtonQuit, ButtonLoadGame, ButtonMachineWhite, ButtonForward,
  426.     ButtonReset, ButtonLoadPosition, ButtonMachineBlack, ButtonBackward,
  427.     ButtonFlipView, ButtonSaveGame, ButtonForceMoves, ButtonPause,
  428.     ButtonHint, ButtonSavePosition, ButtonTwoMachines, ButtonEditPosition
  429. } Button;
  430.  
  431. #define PIECE_MENU_SIZE 18
  432. String pieceMenuStrings[PIECE_MENU_SIZE] = {
  433.     "----", "Pawn", "Lance", "Knight", "Silver",
  434.                 "Gold", "Bishop", "Rook",
  435.         "PPawn", "PLance", "PKnight", "PSilver",
  436.         "PBishop", "PRook", "King",
  437.     "----", "Empty square", "Clear board"
  438. };
  439. /* must be in same order as PieceMenuStrings! */
  440. ChessSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] = {
  441.     { (ChessSquare) 0, BlackPawn, BlackLance, BlackKnight, BlackSilver, 
  442.          BlackGold, BlackBishop, BlackRook,
  443.         BlackPPawn, BlackPLance, BlackPKnight, BlackPSilver,
  444.         BlackPBishop, BlackPRook, BlackKing,
  445.          (ChessSquare) 0, EmptySquare, ClearBoard },
  446.     { (ChessSquare) 0, WhitePawn, WhiteLance, WhiteKnight, WhiteSilver, 
  447.          WhiteGold, WhiteBishop, WhiteRook,
  448.         WhitePPawn, WhitePLance, WhitePKnight, WhitePSilver,
  449.         WhitePBishop, WhitePRook, WhiteKing,
  450.          (ChessSquare) 0, EmptySquare, ClearBoard },
  451. };
  452.  
  453. Arg shellArgs[] = {
  454.     { XtNwidth, 0 },
  455.     { XtNheight, 0 },
  456.     { XtNminWidth, 0 },
  457.     { XtNminHeight, 0 },
  458.     { XtNmaxWidth, 0 },
  459.     { XtNmaxHeight, 0 }
  460. };
  461.  
  462. Arg boardArgs[] = {
  463.     { XtNborderWidth, 0 },
  464.     { XtNwidth, LINE_GAP + (BOARD_SIZE+4) * (SMALL_SQUARE_SIZE + LINE_GAP) },
  465.     { XtNheight, LINE_GAP + BOARD_SIZE * (SMALL_SQUARE_SIZE + LINE_GAP) }
  466. };
  467.  
  468. Arg commandsArgs[] = {
  469.     { XtNborderWidth, 0 },
  470.     { XtNdefaultColumns, 4 },
  471.     { XtNforceColumns, True },
  472.     { XtNlist, (XtArgVal) buttonStrings },
  473.     { XtNnumberStrings, XtNumber(buttonStrings) }
  474. };
  475.  
  476. Arg messageArgs[] = {
  477.     { XtNborderWidth, 0 },
  478.     { XtNjustify, (XtArgVal) XtJustifyLeft },
  479.     { XtNlabel, (XtArgVal) "starting..." }
  480. };
  481.  
  482. Arg timerArgs[] = {
  483.     { XtNborderWidth, 0 },
  484.     { XtNjustify, (XtArgVal) XtJustifyLeft }
  485. };
  486.  
  487. Arg nameArgs[] = {
  488.     { XtNborderWidth, 0 },
  489.     { XtNjustify, (XtArgVal) XtJustifyLeft }
  490. };
  491.  
  492. typedef struct {
  493.     Pixel blackPieceColor;
  494.     Pixel whitePieceColor;
  495.     Pixel lightSquareColor;
  496.     Pixel darkSquareColor;
  497.     int movesPerSession;
  498.     String initString;
  499.     String blackString;
  500.     String whiteString;
  501.     String firstChessProgram;
  502.     String secondChessProgram;
  503.     Boolean noChessProgram;
  504.     String firstHost;
  505.     String secondHost;
  506.     String reverseBigSolidBitmap;
  507.     String reverseSmallSolidBitmap;
  508.     String normalBigSolidBitmap;
  509.     String normalSmallSolidBitmap;
  510.     String reversePawnBitmap;
  511.     String reverseLanceBitmap;
  512.     String reverseKnightBitmap;
  513.     String reverseSilverBitmap;
  514.     String reverseGoldBitmap;
  515.     String reverseRookBitmap;
  516.     String reverseBishopBitmap;
  517.     String reversePPawnBitmap;
  518.     String reversePLanceBitmap;
  519.     String reversePKnightBitmap;
  520.     String reversePSilverBitmap;
  521.     String reversePBishopBitmap;
  522.     String reversePRookBitmap;
  523.     String reverseKingBitmap;
  524.     String normalPawnBitmap;
  525.     String normalLanceBitmap;
  526.     String normalKnightBitmap;
  527.     String normalSilverBitmap;
  528.     String normalGoldBitmap;
  529.     String normalRookBitmap;
  530.     String normalBishopBitmap;
  531.     String normalPPawnBitmap;
  532.     String normalPLanceBitmap;
  533.     String normalPKnightBitmap;
  534.     String normalPSilverBitmap;
  535.     String normalPBishopBitmap;
  536.     String normalPRookBitmap;
  537.     String normalKingBitmap;
  538.     String remoteShell;
  539.     float timeDelay;
  540.     String timeControl;
  541.     String loadGameFile;
  542.     String loadPositionFile;
  543.     String saveGameFile;
  544.     String savePositionFile;
  545.     String matchMode;
  546.     Boolean monoMode;
  547.     Boolean debugMode;
  548.     Boolean clockMode;
  549.     String boardSize;
  550.     Boolean Iconic;
  551.     String searchTime;
  552.     int searchDepth;
  553.         Boolean showCoords;
  554.     String coordFont;
  555. } AppData, *AppDataPtr;
  556.  
  557. AppData appData;
  558.  
  559. XtResource clientResources[] = {
  560.     {
  561.         "blackPieceColor", "BlackPieceColor", XtRPixel, sizeof(Pixel),
  562.         XtOffset(AppDataPtr, blackPieceColor), XtRString,
  563.         BLACK_PIECE_COLOR
  564.     }, {
  565.         "whitePieceColor", "WhitePieceColor", XtRPixel, sizeof(Pixel),
  566.         XtOffset(AppDataPtr, whitePieceColor), XtRString,
  567.         WHITE_PIECE_COLOR
  568.     }, {
  569.         "lightSquareColor", "LightSquareColor", XtRPixel,
  570.         sizeof(Pixel), XtOffset(AppDataPtr, lightSquareColor),
  571.         XtRString, LIGHT_SQUARE_COLOR
  572.     }, {
  573.         "darkSquareColor", "DarkSquareColor", XtRPixel, sizeof(Pixel),
  574.         XtOffset(AppDataPtr, darkSquareColor), XtRString,
  575.         DARK_SQUARE_COLOR
  576.     }, {
  577.         "movesPerSession", "movesPerSession", XtRInt, sizeof(int),
  578.         XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
  579.         (XtPointer) MOVES_PER_SESSION
  580.     }, {
  581.         "initString", "initString", XtRString, sizeof(String),
  582.         XtOffset(AppDataPtr, initString), XtRString, INIT_STRING
  583.     }, {
  584.         "blackString", "blackString", XtRString, sizeof(String),
  585.         XtOffset(AppDataPtr, blackString), XtRString, BLACK_STRING
  586.     }, {
  587.         "whiteString", "whiteString", XtRString, sizeof(String),
  588.         XtOffset(AppDataPtr, whiteString), XtRString, WHITE_STRING
  589.     }, {
  590.         "firstChessProgram", "firstChessProgram", XtRString,
  591.         sizeof(String), XtOffset(AppDataPtr, firstChessProgram),
  592.         XtRString, FIRST_CHESS_PROGRAM
  593.     }, {
  594.         "secondChessProgram", "secondChessProgram", XtRString,
  595.         sizeof(String), XtOffset(AppDataPtr, secondChessProgram),
  596.         XtRString, SECOND_CHESS_PROGRAM
  597.     }, {
  598.         "noChessProgram", "noChessProgram", XtRBoolean,
  599.         sizeof(Boolean), XtOffset(AppDataPtr, noChessProgram),
  600.         XtRImmediate, (XtPointer) False
  601.     }, {
  602.         "firstHost", "firstHost", XtRString, sizeof(String),
  603.         XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST
  604.     }, {
  605.         "secondHost", "secondHost", XtRString, sizeof(String),
  606.         XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST
  607.     }, {
  608.         "reversePawnBitmap", "reversePawnBitmap", XtRString,
  609.         sizeof(String), XtOffset(AppDataPtr, reversePawnBitmap),
  610.         XtRString, NULL
  611.     }, {
  612.         "reverseLanceBitmap", "reverseLanceBitmap", XtRString,
  613.         sizeof(String), XtOffset(AppDataPtr, reverseLanceBitmap),
  614.         XtRString, NULL
  615.     }, {
  616.         "reverseKnightBitmap", "reverseKnightBitmap", XtRString,
  617.         sizeof(String), XtOffset(AppDataPtr, reverseKnightBitmap),
  618.         XtRString, NULL
  619.     }, {
  620.         "reverseSilverBitmap", "reverseSilverBitmap", XtRString,
  621.         sizeof(String), XtOffset(AppDataPtr, reverseSilverBitmap),
  622.         XtRString, NULL
  623.     }, {
  624.         "reverseGoldBitmap", "reverseGoldBitmap", XtRString,
  625.         sizeof(String), XtOffset(AppDataPtr, reverseGoldBitmap),
  626.         XtRString, NULL
  627.     }, {
  628.         "reverseRookBitmap", "reverseRookBitmap", XtRString,
  629.         sizeof(String), XtOffset(AppDataPtr, reverseRookBitmap),
  630.         XtRString, NULL
  631.     }, {
  632.         "reverseBishopBitmap", "reverseBishopBitmap", XtRString,
  633.         sizeof(String), XtOffset(AppDataPtr, reverseBishopBitmap),
  634.         XtRString, NULL
  635.     }, {
  636.         "reversePPawnBitmap", "reversePPawnBitmap", XtRString,
  637.         sizeof(String), XtOffset(AppDataPtr, reversePPawnBitmap),
  638.         XtRString, NULL
  639.     }, {
  640.         "reversePLanceBitmap", "reversePLanceBitmap", XtRString,
  641.         sizeof(String), XtOffset(AppDataPtr, reversePLanceBitmap),
  642.         XtRString, NULL
  643.     }, {
  644.         "reversePKnightBitmap", "reversePKnightBitmap", XtRString,
  645.         sizeof(String), XtOffset(AppDataPtr, reversePKnightBitmap),
  646.         XtRString, NULL
  647.     }, {
  648.         "reversePSilverBitmap", "reversePSilverBitmap", XtRString,
  649.         sizeof(String), XtOffset(AppDataPtr, reversePSilverBitmap),
  650.         XtRString, NULL
  651.     }, {
  652.         "reversePRookBitmap", "reversePRookBitmap", XtRString,
  653.         sizeof(String), XtOffset(AppDataPtr, reversePRookBitmap),
  654.         XtRString, NULL
  655.     }, {
  656.         "reversePBishopBitmap", "reversePBishopBitmap", XtRString,
  657.         sizeof(String), XtOffset(AppDataPtr, reversePBishopBitmap),
  658.         XtRString, NULL
  659.     }, {
  660.         "reverseKingBitmap", "reverseKingBitmap", XtRString,
  661.         sizeof(String), XtOffset(AppDataPtr, reverseKingBitmap),
  662.         XtRString, NULL
  663.     }, {
  664.         "normalPawnBitmap", "normalPawnBitmap", XtRString,
  665.         sizeof(String), XtOffset(AppDataPtr, normalPawnBitmap),
  666.         XtRString, NULL
  667.     }, {
  668.         "normalLanceBitmap", "normalLanceBitmap", XtRString,
  669.         sizeof(String), XtOffset(AppDataPtr, normalLanceBitmap),
  670.         XtRString, NULL
  671.     }, {
  672.         "normalKnightBitmap", "normalKnightBitmap", XtRString,
  673.         sizeof(String), XtOffset(AppDataPtr, normalKnightBitmap),
  674.         XtRString, NULL
  675.     }, {
  676.         "normalSilverBitmap", "normalSilverBitmap", XtRString,
  677.         sizeof(String), XtOffset(AppDataPtr, normalSilverBitmap),
  678.         XtRString, NULL
  679.     }, {
  680.         "normalGoldBitmap", "normalGoldBitmap", XtRString,
  681.         sizeof(String), XtOffset(AppDataPtr, normalGoldBitmap),
  682.         XtRString, NULL
  683.     }, {
  684.         "normalBishopBitmap", "normalBishopBitmap", XtRString,
  685.         sizeof(String), XtOffset(AppDataPtr, normalBishopBitmap),
  686.         XtRString, NULL
  687.     }, {
  688.         "normalRookBitmap", "normalRookBitmap", XtRString,
  689.         sizeof(String), XtOffset(AppDataPtr, normalRookBitmap),
  690.         XtRString, NULL
  691.     }, {
  692.         "normalPPawnBitmap", "normalPPawnBitmap", XtRString,
  693.         sizeof(String), XtOffset(AppDataPtr, normalPPawnBitmap),
  694.         XtRString, NULL
  695.     }, {
  696.         "normalPLanceBitmap", "normalPLanceBitmap", XtRString,
  697.         sizeof(String), XtOffset(AppDataPtr, normalPLanceBitmap),
  698.         XtRString, NULL
  699.     }, {
  700.         "normalPKnightBitmap", "normalPKnightBitmap", XtRString,
  701.         sizeof(String), XtOffset(AppDataPtr, normalPKnightBitmap),
  702.         XtRString, NULL
  703.     }, {
  704.         "normalPSilverBitmap", "normalPSilverBitmap", XtRString,
  705.         sizeof(String), XtOffset(AppDataPtr, normalPSilverBitmap),
  706.         XtRString, NULL
  707.     }, {
  708.         "normalPBishopBitmap", "normalPBishopBitmap", XtRString,
  709.         sizeof(String), XtOffset(AppDataPtr, normalPBishopBitmap),
  710.         XtRString, NULL
  711.     }, {
  712.         "normalPRookBitmap", "normalPRookBitmap", XtRString,
  713.         sizeof(String), XtOffset(AppDataPtr, normalPRookBitmap),
  714.         XtRString, NULL
  715.     }, {
  716.         "normalKingBitmap", "normalKingBitmap", XtRString,
  717.         sizeof(String), XtOffset(AppDataPtr, normalKingBitmap),
  718.         XtRString, NULL
  719.     }, {
  720.         "remoteShell", "remoteShell", XtRString, sizeof(String),
  721.         XtOffset(AppDataPtr, remoteShell), XtRString, "rsh"
  722.     }, {
  723.         "timeDelay", "timeDelay", XtRFloat, sizeof(float),
  724.         XtOffset(AppDataPtr, timeDelay), XtRString,
  725.         (XtPointer) TIME_DELAY
  726.     }, {
  727.         "timeControl", "timeControl", XtRString, sizeof(String),
  728.         XtOffset(AppDataPtr, timeControl), XtRString,
  729.         (XtPointer) TIME_CONTROL
  730.     }, {
  731.         "loadGameFile", "loadGameFile", XtRString, sizeof(String),
  732.         XtOffset(AppDataPtr, loadGameFile), XtRString, NULL
  733.     }, {
  734.         "loadPositionFile", "loadPositionFile", XtRString,
  735.         sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
  736.         XtRString, NULL
  737.     }, {
  738.         "saveGameFile", "saveGameFile", XtRString, sizeof(String),
  739.         XtOffset(AppDataPtr, saveGameFile), XtRString, ""
  740.     }, {
  741.         "savePositionFile", "savePositionFile", XtRString,
  742.         sizeof(String), XtOffset(AppDataPtr, savePositionFile),
  743.         XtRString, ""
  744.     }, {
  745.         "matchMode", "matchMode", XtRString, sizeof(String),
  746.         XtOffset(AppDataPtr, matchMode), XtRString, MATCH_MODE
  747.     }, {
  748.         "monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
  749.         XtOffset(AppDataPtr, monoMode), XtRImmediate,
  750.         (XtPointer) False
  751.     }, {
  752.         "debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
  753.         XtOffset(AppDataPtr, debugMode), XtRImmediate,
  754.         (XtPointer) False
  755.     }, {
  756.         "Iconic", "Iconic", XtRBoolean, sizeof(Boolean),
  757.         XtOffset(AppDataPtr, Iconic), XtRImmediate,
  758.         (XtPointer) False
  759.     }, {
  760.         "clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
  761.         XtOffset(AppDataPtr, clockMode), XtRImmediate,
  762.         (XtPointer) True
  763.     }, {
  764.         "boardSize", "boardSize", XtRString, sizeof(String),
  765.         XtOffset(AppDataPtr, boardSize), XtRString, DEFAULT_SIZE
  766.     }, {
  767.         "searchTime", "searchTime", XtRString, sizeof(String),
  768.         XtOffset(AppDataPtr, searchTime), XtRString,
  769.         (XtPointer) NULL
  770.     }, {
  771.         "searchDepth", "searchDepth", XtRInt, sizeof(int),
  772.         XtOffset(AppDataPtr, searchDepth), XtRImmediate, 
  773.         (XtPointer) 0
  774.     }, {
  775.         "showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
  776.         XtOffset(AppDataPtr, showCoords), XtRImmediate,
  777.         (XtPointer) False
  778.     }, {
  779.         "coordFont", "coordFont", XtRString, sizeof(String),
  780.         XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT
  781.     }
  782. };
  783.  
  784. Pixmap *pieceToReverse[] = {
  785.     &reversePawnBitmap, &reverseLanceBitmap, &reverseKnightBitmap,
  786.     &reverseSilverBitmap, &reverseGoldBitmap, &reverseBishopBitmap,
  787.         &reverseRookBitmap, &reversePPawnBitmap, &reversePLanceBitmap,
  788.         &reversePKnightBitmap, &reversePSilverBitmap, &reversePBishopBitmap,
  789.         &reversePRookBitmap, &reverseKingBitmap,
  790.     &reversePawnBitmap, &reverseLanceBitmap, &reverseKnightBitmap,
  791.     &reverseSilverBitmap, &reverseGoldBitmap, &reverseBishopBitmap,
  792.         &reverseRookBitmap, &reversePPawnBitmap, &reversePLanceBitmap,
  793.         &reversePKnightBitmap, &reversePSilverBitmap, &reversePBishopBitmap,
  794.         &reversePRookBitmap, &reverseKingBitmap
  795. };
  796.  
  797. Pixmap *pieceToNormal[] = {
  798.     &normalPawnBitmap, &normalLanceBitmap, &normalKnightBitmap,
  799.     &normalSilverBitmap, &normalGoldBitmap, &normalBishopBitmap,
  800.         &normalRookBitmap, &normalPPawnBitmap, &normalPLanceBitmap,
  801.         &normalPKnightBitmap, &normalPSilverBitmap, &normalPBishopBitmap,
  802.         &normalPRookBitmap, &normalKingBitmap,
  803.     &normalPawnBitmap, &normalLanceBitmap, &normalKnightBitmap,
  804.     &normalSilverBitmap, &normalGoldBitmap, &normalBishopBitmap,
  805.         &normalRookBitmap, &normalPPawnBitmap, &normalPLanceBitmap,
  806.         &normalPKnightBitmap, &normalPSilverBitmap, &normalPBishopBitmap,
  807.         &normalPRookBitmap, &normalKingBitmap
  808. };
  809.  
  810. Pixmap *pieceToReverseSolid[] = {
  811.     &reverseSmallSolidBitmap, &reverseSmallSolidBitmap, &reverseSmallSolidBitmap,
  812.     &reverseBigSolidBitmap, &reverseBigSolidBitmap, &reverseBigSolidBitmap,
  813.         &reverseBigSolidBitmap, &reverseSmallSolidBitmap, &reverseSmallSolidBitmap,
  814.         &reverseSmallSolidBitmap, &reverseBigSolidBitmap, &reverseBigSolidBitmap,
  815.         &reverseBigSolidBitmap, &reverseBigSolidBitmap,
  816.     &reverseSmallSolidBitmap, &reverseSmallSolidBitmap, &reverseSmallSolidBitmap,
  817.     &reverseBigSolidBitmap, &reverseBigSolidBitmap, &reverseBigSolidBitmap,
  818.         &reverseBigSolidBitmap, &reverseSmallSolidBitmap, &reverseSmallSolidBitmap,
  819.         &reverseSmallSolidBitmap, &reverseBigSolidBitmap, &reverseBigSolidBitmap,
  820.         &reverseBigSolidBitmap, &reverseBigSolidBitmap,
  821. };
  822.  
  823. Pixmap *pieceToNormalSolid[] = {
  824.     &normalSmallSolidBitmap, &normalSmallSolidBitmap, &normalSmallSolidBitmap,
  825.     &normalBigSolidBitmap, &normalBigSolidBitmap, &normalBigSolidBitmap,
  826.         &normalBigSolidBitmap, &normalSmallSolidBitmap, &normalSmallSolidBitmap,
  827.         &normalSmallSolidBitmap, &normalBigSolidBitmap, &normalBigSolidBitmap,
  828.         &normalBigSolidBitmap, &normalBigSolidBitmap,
  829.     &normalSmallSolidBitmap, &normalSmallSolidBitmap, &normalSmallSolidBitmap,
  830.     &normalBigSolidBitmap, &normalBigSolidBitmap, &normalBigSolidBitmap,
  831.         &normalBigSolidBitmap, &normalSmallSolidBitmap, &normalSmallSolidBitmap,
  832.         &normalSmallSolidBitmap, &normalBigSolidBitmap, &normalBigSolidBitmap,
  833.         &normalBigSolidBitmap, &normalBigSolidBitmap,
  834. };
  835.  
  836. int pieceIsPromoted[] = {
  837.      False, False, False, False, False, False, False,  
  838.         True,  True,  True,  True,  True,  True,  False,
  839.      False, False, False, False, False, False, False,  
  840.         True,  True,  True,  True,  True,  True,  False,
  841.         False
  842. };
  843.  
  844. int piecePromotable[] = {
  845.      True,  True,  True,  True,  False, True,  True,  
  846.      False, False, False, False, False, False, False,  
  847.      True,  True,  True,  True,  False, True,  True,  
  848.      False, False, False, False, False, False, False,  
  849.         False
  850. };
  851.  
  852. char pieceToChar[] = {                               
  853.     'P', 'L', 'N', 'S', 'G', 'B', 'R', 'P', 'L', 'N', 'S', 'B', 'R', 'K',
  854.     'p', 'l', 'n', 's', 'g', 'b', 'r', 'p', 'l', 'n', 's', 'b', 'r', 'k', 
  855.         '.'
  856. };  
  857.  
  858.  
  859. #ifdef WESTERN_BITMAPS
  860.  
  861. int pieceisWhite[] = {
  862.      True,  True,  True,  True,  True, True,  True,  
  863.      True, True, True, True, True, True, True,  
  864.      False, False, False, False, False, False, False,  
  865.      False, False, False, False, False, False, False,  
  866.         False
  867. };
  868.  
  869. #endif
  870.  
  871.  
  872. ChessSquare pieceToPromoted[] = {                               
  873.     BlackPPawn, BlackPLance, BlackPKnight, BlackPSilver, BlackGold,
  874.     BlackPBishop, BlackPRook,
  875.     BlackPPawn, BlackPLance, BlackPKnight, BlackPSilver, 
  876.     BlackPBishop, BlackPRook, BlackKing,
  877.     WhitePPawn, WhitePLance, WhitePKnight, WhitePSilver, WhiteGold,
  878.     WhitePBishop, WhitePRook,
  879.     WhitePPawn, WhitePLance, WhitePKnight, WhitePSilver, 
  880.     WhitePBishop, WhitePRook, WhiteKing
  881. };
  882.  
  883. XrmOptionDescRec shellOptions[] = {
  884.     { "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
  885.     { "-wpc", "blackPieceColor", XrmoptionSepArg, NULL },
  886.     { "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
  887.     { "-bpc", "whitePieceColor", XrmoptionSepArg, NULL },
  888.     { "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
  889.     { "-lsc", "lightSquareColor", XrmoptionSepArg, NULL },
  890.     { "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
  891.     { "-dsc", "darkSquareColor", XrmoptionSepArg, NULL },
  892.     { "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
  893.     { "-mps", "movesPerSession", XrmoptionSepArg, NULL },
  894.     { "-firstChessProgram", "firstChessProgram", XrmoptionSepArg, NULL },
  895.     { "-fcp", "firstChessProgram", XrmoptionSepArg, NULL },
  896.     { "-secondChessProgram", "secondChessProgram", XrmoptionSepArg, NULL },
  897.     { "-scp", "secondChessProgram", XrmoptionSepArg, NULL },
  898.     { "-noChessProgram", "noChessProgram", XrmoptionSepArg, NULL },
  899.     { "-ncp", "noChessProgram", XrmoptionSepArg, NULL },
  900.     { "-firstHost", "firstHost", XrmoptionSepArg, NULL },
  901.     { "-fh", "firstHost", XrmoptionSepArg, NULL },
  902.     { "-secondHost", "secondHost", XrmoptionSepArg, NULL },
  903.     { "-sh", "secondHost", XrmoptionSepArg, NULL },
  904.     { "-reversePawnBitmap", "reversePawnBitmap", XrmoptionSepArg, NULL },
  905.     { "-rpb", "reversePawnBitmap", XrmoptionSepArg, NULL },
  906.     { "-reverseLanceBitmap", "reverseLanceBitmap", XrmoptionSepArg, NULL },
  907.     { "-rlb", "reverseLanceBitmap", XrmoptionSepArg, NULL },
  908.     { "-reverseKnightBitmap", "reverseKnightBitmap", XrmoptionSepArg, NULL },
  909.     { "-rnb", "reverseKnightBitmap", XrmoptionSepArg, NULL },
  910.     { "-reverseSilverBitmap", "reverseSilverBitmap", XrmoptionSepArg, NULL },
  911.     { "-rsb", "reverseSilverBitmap", XrmoptionSepArg, NULL },
  912.     { "-reverseGoldBitmap", "reverseGoldBitmap", XrmoptionSepArg, NULL },
  913.     { "-rgb", "reverseGoldBitmap", XrmoptionSepArg, NULL },
  914.     { "-reverseRookBitmap", "reverseRookBitmap", XrmoptionSepArg, NULL },
  915.     { "-rrb", "reverseRookBitmap", XrmoptionSepArg, NULL },
  916.     { "-reverseBishopBitmap", "reverseBishopBitmap", XrmoptionSepArg, NULL },
  917.     { "-rbb", "reverseBishopBitmap", XrmoptionSepArg, NULL },
  918.     { "-reversePPawnBitmap", "reversePPawnBitmap", XrmoptionSepArg, NULL },
  919.     { "-rppb", "reversePPawnBitmap", XrmoptionSepArg, NULL },
  920.     { "-reversePLanceBitmap", "reversePLanceBitmap", XrmoptionSepArg, NULL },
  921.     { "-rplb", "reversePLanceBitmap", XrmoptionSepArg, NULL },
  922.     { "-reversePKnightBitmap", "reversePKnightBitmap", XrmoptionSepArg, NULL },
  923.     { "-rpnb", "reversePKnightBitmap", XrmoptionSepArg, NULL },
  924.     { "-reversePSilverBitmap", "reversePSilverBitmap", XrmoptionSepArg, NULL },
  925.     { "-rpsb", "reversePSilverBitmap", XrmoptionSepArg, NULL },
  926.     { "-reversePRookBitmap", "reversePRookBitmap", XrmoptionSepArg, NULL },
  927.     { "-rprb", "reversePRookBitmap", XrmoptionSepArg, NULL },
  928.     { "-reversePBishopBitmap", "reversePBishopBitmap", XrmoptionSepArg, NULL },
  929.     { "-rpbb", "reversePBishopBitmap", XrmoptionSepArg, NULL },
  930.     { "-reverseKingBitmap", "reverseKingBitmap", XrmoptionSepArg, NULL },
  931.     { "-rkb", "reverseKingBitmap", XrmoptionSepArg, NULL },
  932.     { "-outlinePawnBitmap", "outlinePawnBitmap", XrmoptionSepArg, NULL },
  933.     { "-opb", "normalPawnBitmap", XrmoptionSepArg, NULL },
  934.     { "-normalLanceBitmap", "normalLanceBitmap", XrmoptionSepArg, NULL },
  935.     { "-olb", "normalLanceBitmap", XrmoptionSepArg, NULL },
  936.     { "-normalKnightBitmap", "normalKnightBitmap", XrmoptionSepArg, NULL },
  937.     { "-onb", "normalKnightBitmap", XrmoptionSepArg, NULL },
  938.     { "-normalSilverBitmap", "normalSilverBitmap", XrmoptionSepArg, NULL },
  939.     { "-osb", "normalSilverBitmap", XrmoptionSepArg, NULL },
  940.     { "-normalGoldBitmap", "normalGoldBitmap", XrmoptionSepArg, NULL },
  941.     { "-ogb", "normalGoldBitmap", XrmoptionSepArg, NULL },
  942.     { "-normalRookBitmap", "normalRookBitmap", XrmoptionSepArg, NULL },
  943.     { "-orb", "normalRookBitmap", XrmoptionSepArg, NULL },
  944.     { "-normalBishopBitmap", "normalBishopBitmap", XrmoptionSepArg, NULL },
  945.     { "-obb", "normalBishopBitmap", XrmoptionSepArg, NULL },
  946.     { "-normalPPawnBitmap", "normalPPawnBitmap", XrmoptionSepArg, NULL },
  947.     { "-oppb", "normalPPawnBitmap", XrmoptionSepArg, NULL },
  948.     { "-normalPLanceBitmap", "normalPLanceBitmap", XrmoptionSepArg, NULL },
  949.     { "-oplb", "normalPLanceBitmap", XrmoptionSepArg, NULL },
  950.     { "-normalPKnightBitmap", "normalPKnightBitmap", XrmoptionSepArg, NULL },
  951.     { "-opnb", "normalPKnightBitmap", XrmoptionSepArg, NULL },
  952.     { "-normalPSilverBitmap", "normalPSilverBitmap", XrmoptionSepArg, NULL },
  953.     { "-opsb", "normalPSilverBitmap", XrmoptionSepArg, NULL },
  954.     { "-normalPRookBitmap", "normalPRookBitmap", XrmoptionSepArg, NULL },
  955.     { "-oprb", "normalPRookBitmap", XrmoptionSepArg, NULL },
  956.     { "-normalPBishopBitmap", "normalPBishopBitmap", XrmoptionSepArg, NULL },
  957.     { "-opbb", "normalPBishopBitmap", XrmoptionSepArg, NULL },
  958.     { "-normalKingBitmap", "normalKingBitmap", XrmoptionSepArg, NULL },
  959.     { "-okb", "outlineKingBitmap", XrmoptionSepArg, NULL },
  960.     { "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
  961.     { "-rsh", "remoteShell", XrmoptionSepArg, NULL },
  962.     { "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
  963.     { "-td", "timeDelay", XrmoptionSepArg, NULL },
  964.     { "-timeControl", "timeControl", XrmoptionSepArg, NULL },
  965.     { "-tc", "timeControl", XrmoptionSepArg, NULL },
  966.     { "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
  967.     { "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
  968.     { "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
  969.     { "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
  970.     { "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
  971.     { "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
  972.     { "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
  973.     { "-spf", "savePositionFile", XrmoptionSepArg, NULL },
  974.     { "-matchMode", "matchMode", XrmoptionSepArg, NULL },
  975.     { "-mm", "matchMode", XrmoptionSepArg, NULL },
  976.     { "-monoMode", "monoMode", XrmoptionSepArg, NULL },
  977.     { "-mono", "monoMode", XrmoptionSepArg, NULL },
  978.     { "-debugMode", "debugMode", XrmoptionSepArg, NULL },
  979.     { "-debug", "debugMode", XrmoptionSepArg, NULL },
  980.     { "-clockMode", "clockMode", XrmoptionSepArg, NULL },
  981.     { "-clock", "clockMode", XrmoptionSepArg, NULL },
  982.     { "-boardSize", "boardSize", XrmoptionSepArg, NULL },
  983.     { "-size", "boardSize", XrmoptionSepArg, NULL },
  984.     { "-searchTime", "searchTime", XrmoptionSepArg, NULL },
  985.     { "-st", "searchTime", XrmoptionSepArg, NULL },
  986.     { "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
  987.     { "-sd", "searchDepth", XrmoptionSepArg, NULL },
  988.     { "-showCoords", "showCoords", XrmoptionSepArg, NULL },
  989.     { "-coords", "showCoords", XrmoptionSepArg, NULL },
  990.     { "-iconic", "Iconic", XrmoptionNoArg, "True" }
  991. };
  992.  
  993. XtActionsRec boardActions[] = {
  994.     { "DrawPosition", (XtActionProc) DrawPosition },
  995.     { "HandleUserMove", (XtActionProc) HandleUserMove },
  996.     { "ResetProc", (XtActionProc) ResetProc },
  997.     { "ResetFileProc", (XtActionProc) ResetFileProc },
  998.     { "GameProc", (XtActionProc) GameProc },
  999.     { "QuitProc", (XtActionProc) QuitProc },
  1000.     { "ForwardProc", (XtActionProc) ForwardProc },
  1001.     { "BackwardProc", (XtActionProc) BackwardProc },
  1002.     { "PauseProc", (XtActionProc) PauseProc },
  1003.     { "Iconify", (XtActionProc) Iconify },
  1004.     { "FileNameAction", (XtActionProc) FileNameAction },
  1005.     { "PieceMenuPopup", (XtActionProc) PieceMenuPopup },
  1006.     { "SetBlackToPlay", (XtActionProc) SetBlackToPlay },
  1007.     { "SetWhiteToPlay", (XtActionProc) SetWhiteToPlay }
  1008. };
  1009.  
  1010. char translationsTable[] =
  1011.     "<Expose>: DrawPosition() \n \
  1012.      <Btn1Down>: HandleUserMove() \n \
  1013.      <Btn1Up>: HandleUserMove() \n \
  1014.      <Btn2Down>: XawPositionSimpleMenu(menuW) PieceMenuPopup(menuW) \n \
  1015.      <Btn3Down>: XawPositionSimpleMenu(menuB) PieceMenuPopup(menuB) \n \
  1016.      <Key>r: ResetFileProc() ResetProc() \n \
  1017.      <Key>R: ResetFileProc() ResetProc() \n \
  1018.      <Key>g: GameProc() \n \
  1019.      <Key>G: GameProc() \n \
  1020.      <Key>q: QuitProc() \n \
  1021.      <Key>Q: QuitProc() \n \
  1022.      <Message>WM_PROTOCOLS: QuitProc() \n \
  1023.      <Key>f: ForwardProc() \n \
  1024.      <Key>F: ForwardProc() \n \
  1025.      <Key>b: BackwardProc() \n \
  1026.      <Key>B: BackwardProc() \n \
  1027.      <Key>p: PauseProc() \n \
  1028.      <Key>P: PauseProc() \n \
  1029.      <Key>i: Iconify() \n \
  1030.      <Key>I: Iconify() \n \
  1031.      <Key>c: Iconify() \n \
  1032.      <Key>C: Iconify() \n";
  1033.  
  1034. char blackTranslations[] = "<BtnDown>: SetBlackToPlay()\n";
  1035. char whiteTranslations[] = "<BtnDown>: SetWhiteToPlay()\n";
  1036.  
  1037. String xshogiResources[] = {
  1038.     "*font: -*-helvetica-medium-o-normal--*-140-*-*-*-*-*-*\n",
  1039.     "*Dialog*value.translations: #override \\n <Key>Return: FileNameAction()",
  1040.     NULL
  1041. };
  1042.  
  1043. void
  1044. main(argc, argv)
  1045.     int argc;
  1046.     char **argv;
  1047. {
  1048.     XSetWindowAttributes window_attributes;
  1049.     char buf[MSG_SIZ];
  1050.     Arg args[3];
  1051.     Dimension timerWidth, boardWidth, commandsWidth, w, h;
  1052.  
  1053.     setbuf(stdout, NULL); setbuf(stderr, NULL);
  1054.  
  1055.     programName = strrchr(argv[0], '/');
  1056.     if (programName == NULL)
  1057.       programName = argv[0];
  1058.     else
  1059.       programName++;
  1060.  
  1061.     shellWidget = XtAppInitialize(&appContext, "XShogi", shellOptions,
  1062.         XtNumber(shellOptions), &argc, argv, xshogiResources, NULL, 0);
  1063.     if (argc > 1)
  1064.         Usage();
  1065.  
  1066.     if ((chessDir = (char *) getenv("CHESSDIR")) == NULL) {
  1067.         chessDir = ".";
  1068.     } else {
  1069.         if (chdir(chessDir) != 0) {
  1070.             fprintf(stderr, "%s: can't cd to CHESSDIR\n",
  1071.                 programName);
  1072.             perror(chessDir);
  1073.             exit(1);
  1074.         }
  1075.     }
  1076.  
  1077.     XtGetApplicationResources(shellWidget, &appData, clientResources,
  1078.         XtNumber(clientResources), NULL, 0);
  1079.  
  1080.     xshogiDebug = appData.debugMode;
  1081.  
  1082.     /*
  1083.      * Determine matchMode state -- poor man's resource converter
  1084.      */
  1085.     if (StrCaseCmp(appData.matchMode, "Init") == 0)
  1086.         matchMode = MatchInit;
  1087.     else if (StrCaseCmp(appData.matchMode, "Position") == 0)
  1088.         matchMode = MatchPosition;
  1089.     else if (StrCaseCmp(appData.matchMode, "Opening") == 0)
  1090.         matchMode = MatchOpening;
  1091.     else if (StrCaseCmp(appData.matchMode, "False") == 0)
  1092.         matchMode = MatchFalse;
  1093.     else {
  1094.         fprintf(stderr, "%s: bad matchMode option %s\n",
  1095.             programName, appData.matchMode);
  1096.         Usage();
  1097.     }
  1098.  
  1099.     /*
  1100.      * Parse timeControl resource
  1101.      */
  1102.     if (appData.timeControl != NULL) {
  1103.         int min, sec, matched;
  1104.  
  1105.         matched = sscanf(appData.timeControl, "%d:%d", &min, &sec);
  1106.         if (matched == 1) {
  1107.             timeControl = min * 60 * 1000;
  1108.         } else if (matched == 2) {
  1109.             timeControl = (min * 60 + sec) * 1000;
  1110.         } else {
  1111.             fprintf(stderr, "%s: bad timeControl option %s\n",
  1112.                 programName, appData.timeControl);
  1113.             Usage();
  1114.         }
  1115.     }
  1116.  
  1117.     /*
  1118.      * Parse searchTime resource
  1119.      */
  1120.     if (appData.searchTime != NULL) {
  1121.         int min, sec, matched;
  1122.  
  1123.         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
  1124.         if (matched == 1) {
  1125.             searchTime = min * 60;
  1126.         } else if (matched == 2) {
  1127.             searchTime = min * 60 + sec;
  1128.         } else {
  1129.             fprintf(stderr, "%s: bad searchTime option %s\n",
  1130.                 programName, appData.searchTime);
  1131.             Usage();
  1132.         }
  1133.     }
  1134.  
  1135.     /*
  1136.      * Determine boardSize
  1137.      */
  1138.     if (StrCaseCmp(appData.boardSize, "Large") == 0)
  1139.         boardSize = Large;
  1140.     else if (StrCaseCmp(appData.boardSize, "Medium") == 0)
  1141.         boardSize = Medium;
  1142.     else if (StrCaseCmp(appData.boardSize, "Small") == 0)
  1143.         boardSize = Small;
  1144.     else {
  1145.         fprintf(stderr, "%s: bad boardSize option %s\n",
  1146.             programName, appData.boardSize);
  1147.         Usage();
  1148.     }
  1149.  
  1150.     xDisplay = XtDisplay(shellWidget);
  1151.     xScreen = DefaultScreen(xDisplay);
  1152.     if (((DisplayWidth(xDisplay, xScreen) < 800)
  1153.          ||    (DisplayHeight(xDisplay, xScreen) < 800))
  1154.         && (boardSize == Large)) {
  1155.         boardSize = Medium;
  1156.     }
  1157.  
  1158.     switch (boardSize) {
  1159.           case Small:
  1160.         squareSize = SMALL_SQUARE_SIZE;
  1161.         break;
  1162.           case Medium:
  1163.         squareSize = MEDIUM_SQUARE_SIZE;
  1164.         break;
  1165.           case Large:
  1166.         squareSize = LARGE_SQUARE_SIZE;
  1167.         break;
  1168.     }
  1169.     boardWidth = LINE_GAP + (BOARD_SIZE+4) * (squareSize + LINE_GAP);
  1170.     XtSetArg(boardArgs[1], XtNwidth, boardWidth);
  1171.     XtSetArg(boardArgs[2], XtNheight,
  1172.          LINE_GAP + BOARD_SIZE * (squareSize + LINE_GAP));
  1173.  
  1174.         if ((appData.searchTime != NULL) || (appData.searchDepth > 0)
  1175.         || appData.noChessProgram)
  1176.       appData.clockMode = False;
  1177.  
  1178.     /*
  1179.      * Detect if there are not enough colors are available and adapt.
  1180.      */
  1181.     if (DefaultDepth(xDisplay, xScreen) <= 2)
  1182.         appData.monoMode = True;
  1183.  
  1184.     /*
  1185.      * widget hierarchy
  1186.      */
  1187.     formWidget = XtCreateManagedWidget("form",
  1188.         formWidgetClass, shellWidget, NULL, 0);
  1189.  
  1190.         widgetList[0] = blackTimerWidget =
  1191.           XtCreateWidget("black time:", labelWidgetClass,
  1192.                  formWidget, timerArgs, XtNumber(timerArgs));
  1193.  
  1194.         widgetList[1] = whiteTimerWidget =
  1195.           XtCreateWidget("white time:", labelWidgetClass,
  1196.                  formWidget, timerArgs, XtNumber(timerArgs));
  1197.  
  1198.         widgetList[2] = nameWidget =
  1199.           XtCreateWidget("", labelWidgetClass,
  1200.                  formWidget, nameArgs, XtNumber(nameArgs));
  1201.  
  1202.         widgetList[3] = messageWidget =
  1203.           XtCreateWidget("message", labelWidgetClass, formWidget,
  1204.                  messageArgs, XtNumber(messageArgs));
  1205.  
  1206.         widgetList[4] = commandsWidget =
  1207.           XtCreateWidget("commands", listWidgetClass, formWidget,
  1208.                  commandsArgs, XtNumber(commandsArgs));
  1209.  
  1210.             widgetList[5] = boardWidget =
  1211.           XtCreateWidget("board", widgetClass, formWidget,
  1212.                  boardArgs, XtNumber(boardArgs));
  1213.  
  1214.     XtManageChildren(widgetList, XtNumber(widgetList));
  1215.  
  1216.     /*
  1217.      * Calculate the width of the timer labels.
  1218.      */
  1219.     XtSetArg(args[0], XtNfont, &labelFont);
  1220.     XtGetValues(blackTimerWidget, args, 1);
  1221.     if (appData.clockMode) {
  1222.         sprintf(buf, "Black: %s ", TimeString(timeControl));
  1223.         timerWidth = XTextWidth(labelFont, buf, strlen(buf) - 1);
  1224.     } else
  1225.         timerWidth = XTextWidth(labelFont, "Black  ", 7);
  1226.     XtSetArg(args[0], XtNwidth, timerWidth);
  1227.     XtSetValues(blackTimerWidget, args, 1);
  1228.     XtSetValues(whiteTimerWidget, args, 1);
  1229.  
  1230.     XtSetArg(args[0], XtNbackground, &timerForegroundPixel);
  1231.     XtSetArg(args[1], XtNforeground, &timerBackgroundPixel);
  1232.     XtGetValues(blackTimerWidget, args, 2);
  1233.  
  1234.     /*
  1235.      * Calculate the width of the name and message labels.
  1236.      */
  1237.     XtSetArg(args[0], XtNwidth, &commandsWidth);
  1238.     XtGetValues(commandsWidget, args, 1);
  1239.         w = (commandsWidth > boardWidth) ? commandsWidth : boardWidth;
  1240.     XtSetArg(args[0], XtNwidth, w - timerWidth*2 - 12);
  1241.     XtSetValues(nameWidget, args, 1);
  1242.     XtSetArg(args[0], XtNwidth, w - 8);
  1243.     XtSetValues(messageWidget, args, 1);
  1244.  
  1245.     /*
  1246.      * formWidget uses these constraints but they are stored
  1247.      * in the children.
  1248.      */
  1249.     XtSetArg(args[0], XtNfromHoriz, blackTimerWidget);
  1250.     XtSetValues(whiteTimerWidget, args, 1);
  1251.     XtSetArg(args[0], XtNfromHoriz, whiteTimerWidget);
  1252.     XtSetValues(nameWidget, args, 1);
  1253.     XtSetArg(args[0], XtNfromVert, blackTimerWidget);
  1254.     XtSetValues(messageWidget, args, 1);
  1255.     XtSetArg(args[0], XtNfromVert, messageWidget);
  1256.     XtSetValues(commandsWidget, args, 1);
  1257.     XtSetArg(args[0], XtNfromVert, commandsWidget);
  1258.     XtSetValues(boardWidget, args, 1);
  1259.  
  1260.     XtRealizeWidget(shellWidget);
  1261.  
  1262.     xBoardWindow = XtWindow(boardWidget);
  1263.  
  1264.     /*
  1265.      * Create an icon.
  1266.      */
  1267.     iconPixmap = XCreateBitmapFromData(xDisplay, XtWindow(shellWidget),
  1268.         icon_bits, icon_width, icon_height);
  1269.     XtSetArg(args[0], XtNiconPixmap, iconPixmap);
  1270.     XtSetValues(shellWidget, args, 1);
  1271.  
  1272.     /*
  1273.      * Create a cursor for the board widget.
  1274.      */
  1275.     window_attributes.cursor = XCreateFontCursor(xDisplay, XC_hand2);
  1276.     XChangeWindowAttributes(xDisplay, xBoardWindow,
  1277.         CWCursor, &window_attributes);
  1278.  
  1279.     /*
  1280.      * Inhibit shell resizing.
  1281.      */
  1282.     shellArgs[0].value = (XtArgVal) &w;
  1283.     shellArgs[1].value = (XtArgVal) &h;
  1284.     XtGetValues(shellWidget, shellArgs, 2);
  1285.     shellArgs[4].value = shellArgs[2].value = w;
  1286.     shellArgs[5].value = shellArgs[3].value = h;
  1287.     XtSetValues(shellWidget, &shellArgs[2], 4);
  1288.  
  1289.     black_pixel_is_zero = (XBlackPixel == 0);
  1290.  
  1291.     CreateGCs();
  1292.     CreateGrid();
  1293.     CreatePieces();
  1294.     CreatePieceMenus();
  1295.  
  1296.     XtAddCallback(commandsWidget, XtNcallback, SelectCommand, NULL);
  1297.     XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
  1298.  
  1299.     XtSetArg(args[0], XtNtranslations,
  1300.         XtParseTranslationTable(translationsTable));
  1301.     XtSetValues(boardWidget, &args[0], 1);
  1302.     XtSetArg(args[0], XtNtranslations,
  1303.         XtParseTranslationTable(blackTranslations));
  1304.     XtSetValues(blackTimerWidget, &args[0], 1);
  1305.     XtSetArg(args[0], XtNtranslations,
  1306.         XtParseTranslationTable(whiteTranslations));
  1307.     XtSetValues(whiteTimerWidget, &args[0], 1);
  1308.  
  1309.     XtAddEventHandler(boardWidget, ExposureMask | ButtonPressMask
  1310.         | ButtonReleaseMask | Button1MotionMask | KeyPressMask,
  1311.         False, (XtEventHandler) EventProc, NULL);
  1312.  
  1313.         sprintf(buf, "xshogi version %s, patchlevel %s based on xboard version %s", 
  1314.                   version, patchlevel, XBOARD_VERSION);
  1315.  
  1316.     /*
  1317.      * If there is to be a machine match, set it up.
  1318.      */
  1319.     if (matchMode != MatchFalse){
  1320.         if (appData.noChessProgram) {
  1321.             fprintf(stderr,
  1322.               "%s: can't have a match with no chess programs!\n",
  1323.               programName);
  1324.             exit(1);
  1325.         }
  1326.         DisplayMessage(buf);
  1327.         TwoMachinesPlayProc();
  1328.     }
  1329.     else {
  1330.         ResetProc();
  1331.         DisplayMessage(buf);
  1332.     }
  1333.  
  1334.     XtAppMainLoop(appContext);
  1335. }
  1336.  
  1337. void
  1338. CreateGCs()
  1339. {
  1340.     XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
  1341.         | GCBackground | GCFunction | GCPlaneMask;
  1342.     XGCValues gc_values;
  1343.     Font coordFontID;
  1344.  
  1345.     gc_values.plane_mask = AllPlanes;
  1346.     gc_values.line_width = LINE_GAP;
  1347.     gc_values.line_style = LineSolid;
  1348.     gc_values.function = GXcopy;
  1349.  
  1350.     gc_values.foreground = XBlackPixel(xDisplay, xScreen);
  1351.     gc_values.background = XBlackPixel(xDisplay, xScreen);
  1352.     lineGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1353.  
  1354.     gc_values.background = XWhitePixel(xDisplay, xScreen);
  1355.     coordGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1356.     coordFontID = XLoadFont(xDisplay, appData.coordFont);
  1357.     coordFont = XQueryFont(xDisplay, coordFontID);
  1358.     XSetFont(xDisplay, coordGC, coordFontID);
  1359.  
  1360.     if (appData.monoMode) {
  1361.         gc_values.foreground = XWhitePixel(xDisplay, xScreen);
  1362.         gc_values.background = XBlackPixel(xDisplay, xScreen);
  1363.         lightSquareGC = darkSquareGC = wbPieceGC
  1364.             = XtGetGC(shellWidget, value_mask, &gc_values);
  1365.         gc_values.foreground = XBlackPixel(xDisplay, xScreen);
  1366.         gc_values.background = XWhitePixel(xDisplay, xScreen);
  1367.         bwPieceGC
  1368.             = XtGetGC(shellWidget, value_mask, &gc_values);
  1369.     } else {
  1370.         gc_values.foreground = XWhitePixel(xDisplay, xScreen);
  1371.         gc_values.background = XBlackPixel(xDisplay, xScreen);
  1372.         wbPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1373.  
  1374.         gc_values.foreground = XBlackPixel(xDisplay, xScreen);
  1375.         gc_values.background = XWhitePixel(xDisplay, xScreen);
  1376.         bwPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1377.  
  1378.         gc_values.foreground = appData.lightSquareColor;
  1379.         gc_values.background = appData.darkSquareColor;
  1380.         lightSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1381.  
  1382.         gc_values.foreground = appData.darkSquareColor;
  1383.         gc_values.background = appData.lightSquareColor;
  1384.         darkSquareGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1385.  
  1386.         gc_values.foreground = appData.blackPieceColor;
  1387.         gc_values.background = appData.darkSquareColor;
  1388.         wdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1389.  
  1390.         gc_values.foreground = appData.blackPieceColor;
  1391.         gc_values.background = appData.lightSquareColor;
  1392.         wlPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1393.  
  1394.         gc_values.foreground = appData.whitePieceColor;
  1395.         gc_values.background = appData.darkSquareColor;
  1396.         bdPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1397.  
  1398.         gc_values.foreground = appData.whitePieceColor;
  1399.         gc_values.background = appData.lightSquareColor;
  1400.         blPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1401.  
  1402.         gc_values.function = (black_pixel_is_zero ? GXand : GXor);
  1403.  
  1404.         gc_values.foreground = XBlackPixel(xDisplay, xScreen);
  1405.         gc_values.background = XWhitePixel(xDisplay, xScreen);
  1406.         charPieceGC = XtGetGC(shellWidget, value_mask, &gc_values);
  1407.  
  1408.     }
  1409. }                
  1410.  
  1411.  
  1412. void
  1413. CreatePieces()
  1414. {
  1415.     XSynchronize(xDisplay, True);    /* Work-around for xlib/xt
  1416.                        buffering bug */
  1417.         
  1418. #ifdef WESTERN_BITMAPS
  1419.  
  1420.        ReadBitmap(appData.reverseBigSolidBitmap, &reverseBigSolidBitmap,
  1421.            NULL,
  1422.            bigsolidR_bits, bigsolidR_bits, bigsolidR_bits);
  1423.     ReadBitmap(appData.reverseSmallSolidBitmap, &reverseSmallSolidBitmap,
  1424.            NULL,
  1425.            smallsolidR_bits, smallsolidR_bits, smallsolidR_bits);
  1426.  
  1427.     ReadBitmap(appData.normalBigSolidBitmap, &normalBigSolidBitmap,
  1428.            NULL,
  1429.            bigsolid_bits, bigsolid_bits, bigsolid_bits);
  1430.     ReadBitmap(appData.normalSmallSolidBitmap, &normalSmallSolidBitmap,
  1431.            NULL,
  1432.            smallsolid_bits, smallsolid_bits, smallsolid_bits);
  1433.  
  1434.     ReadBitmap(appData.reversePawnBitmap, &reversePawnBitmap,
  1435.            &reverseSmallSolidBitmap,
  1436.            pawnR_bits, pawnR_bits, pawnR_bits);
  1437.     ReadBitmap(appData.reverseLanceBitmap, &reverseLanceBitmap,
  1438.            &reverseSmallSolidBitmap,
  1439.            lanceR_bits, lanceR_bits, lanceR_bits);
  1440.     ReadBitmap(appData.reverseKnightBitmap, &reverseKnightBitmap,
  1441.            &reverseSmallSolidBitmap,
  1442.            knightR_bits, knightR_bits, knightR_bits);
  1443.     ReadBitmap(appData.reverseSilverBitmap, &reverseSilverBitmap,
  1444.            &reverseBigSolidBitmap,
  1445.            silverR_bits, silverR_bits, silverR_bits);
  1446.     ReadBitmap(appData.reverseGoldBitmap, &reverseGoldBitmap,
  1447.            &reverseBigSolidBitmap,
  1448.            goldR_bits, goldR_bits, goldR_bits);
  1449.     ReadBitmap(appData.reverseRookBitmap, &reverseRookBitmap,
  1450.            &reverseBigSolidBitmap,
  1451.            rookR_bits, rookR_bits, rookR_bits);
  1452.     ReadBitmap(appData.reverseBishopBitmap, &reverseBishopBitmap,
  1453.            &reverseBigSolidBitmap,
  1454.            bishopR_bits, bishopR_bits, bishopR_bits);
  1455.     ReadBitmap(appData.reversePPawnBitmap, &reversePPawnBitmap,
  1456.            &reverseSmallSolidBitmap,
  1457.            pawnPR_bits, pawnPR_bits, pawnPR_bits);
  1458.     ReadBitmap(appData.reversePLanceBitmap, &reversePLanceBitmap,
  1459.            &reverseSmallSolidBitmap,
  1460.            lancePR_bits, lancePR_bits, lancePR_bits);
  1461.     ReadBitmap(appData.reversePKnightBitmap, &reversePKnightBitmap,
  1462.            &reverseSmallSolidBitmap,
  1463.            knightPR_bits, knightPR_bits, knightPR_bits);
  1464.     ReadBitmap(appData.reversePSilverBitmap, &reversePSilverBitmap,
  1465.            &reverseBigSolidBitmap,
  1466.            silverPR_bits, silverPR_bits, silverPR_bits);
  1467.     ReadBitmap(appData.reversePRookBitmap, &reversePRookBitmap,
  1468.            &reverseBigSolidBitmap,
  1469.            rookPR_bits, rookPR_bits, rookPR_bits);
  1470.     ReadBitmap(appData.reversePBishopBitmap, &reversePBishopBitmap,
  1471.            &reverseBigSolidBitmap,
  1472.            bishopPR_bits, bishopPR_bits, bishopPR_bits);
  1473.     ReadBitmap(appData.reverseKingBitmap, &reverseKingBitmap,
  1474.            &reverseBigSolidBitmap,
  1475.            kingR_bits, kingR_bits, kingR_bits);
  1476.  
  1477.     ReadBitmap(appData.normalPawnBitmap, &normalPawnBitmap,
  1478.            &normalSmallSolidBitmap,
  1479.            pawn_bits, pawn_bits, pawn_bits);
  1480.     ReadBitmap(appData.normalLanceBitmap, &normalLanceBitmap,
  1481.            &normalSmallSolidBitmap,
  1482.            lance_bits, lance_bits, lance_bits);
  1483.     ReadBitmap(appData.normalKnightBitmap, &normalKnightBitmap,
  1484.            &normalSmallSolidBitmap,
  1485.            knight_bits, knight_bits, knight_bits);
  1486.     ReadBitmap(appData.normalSilverBitmap, &normalSilverBitmap,
  1487.            &normalBigSolidBitmap,
  1488.            silver_bits, silver_bits, silver_bits);
  1489.     ReadBitmap(appData.normalGoldBitmap, &normalGoldBitmap,
  1490.            &normalBigSolidBitmap,
  1491.            gold_bits, gold_bits, gold_bits);
  1492.     ReadBitmap(appData.normalRookBitmap, &normalRookBitmap,
  1493.            &normalBigSolidBitmap,
  1494.            rook_bits, rook_bits, rook_bits);
  1495.     ReadBitmap(appData.normalBishopBitmap, &normalBishopBitmap,
  1496.            &normalBigSolidBitmap,
  1497.            bishop_bits, bishop_bits, bishop_bits);
  1498.     ReadBitmap(appData.normalPPawnBitmap, &normalPPawnBitmap,
  1499.            &normalSmallSolidBitmap,
  1500.            pawnP_bits, pawnP_bits, pawnP_bits);
  1501.     ReadBitmap(appData.normalPLanceBitmap, &normalPLanceBitmap,
  1502.            &normalSmallSolidBitmap,
  1503.            lanceP_bits, lanceP_bits, lanceP_bits);
  1504.     ReadBitmap(appData.normalPKnightBitmap, &normalPKnightBitmap,
  1505.            &normalSmallSolidBitmap,
  1506.            knightP_bits, knightP_bits, knightP_bits);
  1507.     ReadBitmap(appData.normalPSilverBitmap, &normalPSilverBitmap,
  1508.            &normalBigSolidBitmap,
  1509.            silverP_bits, silverP_bits, silverP_bits);
  1510.     ReadBitmap(appData.normalPRookBitmap, &normalPRookBitmap,
  1511.            &normalBigSolidBitmap,
  1512.            rookP_bits, rookP_bits, rookP_bits);
  1513.     ReadBitmap(appData.normalPBishopBitmap, &normalPBishopBitmap,
  1514.            &normalBigSolidBitmap,
  1515.            bishopP_bits, bishopP_bits, bishopP_bits);
  1516.     ReadBitmap(appData.normalKingBitmap, &normalKingBitmap,
  1517.            &normalBigSolidBitmap,
  1518.            king_bits, king_bits, king_bits);
  1519.  
  1520. #else
  1521.                                      
  1522.        ReadBitmap(appData.reverseBigSolidBitmap, &reverseBigSolidBitmap,
  1523.            NULL,
  1524.            bigsolidR_bits, bigsolidR_m_bits, bigsolidR_l_bits);
  1525.     ReadBitmap(appData.reverseSmallSolidBitmap, &reverseSmallSolidBitmap,
  1526.            NULL,
  1527.            smallsolidR_bits, smallsolidR_m_bits, smallsolidR_l_bits);
  1528.  
  1529.     ReadBitmap(appData.normalBigSolidBitmap, &normalBigSolidBitmap,
  1530.            NULL,
  1531.            bigsolid_bits, bigsolid_m_bits, bigsolid_l_bits);
  1532.     ReadBitmap(appData.normalSmallSolidBitmap, &normalSmallSolidBitmap,
  1533.            NULL,
  1534.            smallsolid_bits, smallsolid_m_bits, smallsolid_l_bits);
  1535.  
  1536.     ReadBitmap(appData.reversePawnBitmap, &reversePawnBitmap,
  1537.            &reverseSmallSolidBitmap,
  1538.            pawnR_bits, pawnR_m_bits, pawnR_l_bits);
  1539.     ReadBitmap(appData.reverseLanceBitmap, &reverseLanceBitmap,
  1540.            &reverseSmallSolidBitmap,
  1541.            lanceR_bits, lanceR_m_bits, lanceR_l_bits);
  1542.     ReadBitmap(appData.reverseKnightBitmap, &reverseKnightBitmap,
  1543.            &reverseSmallSolidBitmap,
  1544.            knightR_bits, knightR_m_bits, knightR_l_bits);
  1545.     ReadBitmap(appData.reverseSilverBitmap, &reverseSilverBitmap,
  1546.            &reverseBigSolidBitmap,
  1547.            silverR_bits, silverR_m_bits, silverR_l_bits);
  1548.     ReadBitmap(appData.reverseGoldBitmap, &reverseGoldBitmap,
  1549.            &reverseBigSolidBitmap,
  1550.            goldR_bits, goldR_m_bits, goldR_l_bits);
  1551.     ReadBitmap(appData.reverseRookBitmap, &reverseRookBitmap,
  1552.            &reverseBigSolidBitmap,
  1553.            rookR_bits, rookR_m_bits, rookR_l_bits);
  1554.     ReadBitmap(appData.reverseBishopBitmap, &reverseBishopBitmap,
  1555.            &reverseBigSolidBitmap,
  1556.            bishopR_bits, bishopR_m_bits, bishopR_l_bits);
  1557.     ReadBitmap(appData.reversePPawnBitmap, &reversePPawnBitmap,
  1558.            &reverseSmallSolidBitmap,
  1559.            pawnPR_bits, pawnPR_m_bits, pawnPR_l_bits);
  1560.     ReadBitmap(appData.reversePLanceBitmap, &reversePLanceBitmap,
  1561.            &reverseSmallSolidBitmap,
  1562.            lancePR_bits, lancePR_m_bits, lancePR_l_bits);
  1563.     ReadBitmap(appData.reversePKnightBitmap, &reversePKnightBitmap,
  1564.            &reverseSmallSolidBitmap,
  1565.            knightPR_bits, knightPR_m_bits, knightPR_l_bits);
  1566.     ReadBitmap(appData.reversePSilverBitmap, &reversePSilverBitmap,
  1567.            &reverseBigSolidBitmap,
  1568.            silverPR_bits, silverPR_m_bits, silverPR_l_bits);
  1569.     ReadBitmap(appData.reversePRookBitmap, &reversePRookBitmap,
  1570.            &reverseBigSolidBitmap,
  1571.            rookPR_bits, rookPR_m_bits, rookPR_l_bits);
  1572.     ReadBitmap(appData.reversePBishopBitmap, &reversePBishopBitmap,
  1573.            &reverseBigSolidBitmap,
  1574.            bishopPR_bits, bishopPR_m_bits, bishopPR_l_bits);
  1575.     ReadBitmap(appData.reverseKingBitmap, &reverseKingBitmap,
  1576.            &reverseBigSolidBitmap,
  1577.            kingR_bits, kingR_m_bits, kingR_l_bits);
  1578.  
  1579.     ReadBitmap(appData.normalPawnBitmap, &normalPawnBitmap,
  1580.            &normalSmallSolidBitmap,
  1581.            pawn_bits, pawn_m_bits, pawn_l_bits);
  1582.     ReadBitmap(appData.normalLanceBitmap, &normalLanceBitmap,
  1583.            &normalSmallSolidBitmap,
  1584.            lance_bits, lance_m_bits, lance_l_bits);
  1585.     ReadBitmap(appData.normalKnightBitmap, &normalKnightBitmap,
  1586.            &normalSmallSolidBitmap,
  1587.            knight_bits, knight_m_bits, knight_l_bits);
  1588.     ReadBitmap(appData.normalSilverBitmap, &normalSilverBitmap,
  1589.            &normalBigSolidBitmap,
  1590.            silver_bits, silver_m_bits, silver_l_bits);
  1591.     ReadBitmap(appData.normalGoldBitmap, &normalGoldBitmap,
  1592.            &normalBigSolidBitmap,
  1593.            gold_bits, gold_m_bits, gold_l_bits);
  1594.     ReadBitmap(appData.normalRookBitmap, &normalRookBitmap,
  1595.            &normalBigSolidBitmap,
  1596.            rook_bits, rook_m_bits, rook_l_bits);
  1597.     ReadBitmap(appData.normalBishopBitmap, &normalBishopBitmap,
  1598.            &normalBigSolidBitmap,
  1599.            bishop_bits, bishop_m_bits, bishop_l_bits);
  1600.     ReadBitmap(appData.normalPPawnBitmap, &normalPPawnBitmap,
  1601.            &normalSmallSolidBitmap,
  1602.            pawnP_bits, pawnP_m_bits, pawnP_l_bits);
  1603.     ReadBitmap(appData.normalPLanceBitmap, &normalPLanceBitmap,
  1604.            &normalSmallSolidBitmap,
  1605.            lanceP_bits, lanceP_m_bits, lanceP_l_bits);
  1606.     ReadBitmap(appData.normalPKnightBitmap, &normalPKnightBitmap,
  1607.            &normalSmallSolidBitmap,
  1608.            knightP_bits, knightP_m_bits, knightP_l_bits);
  1609.     ReadBitmap(appData.normalPSilverBitmap, &normalPSilverBitmap,
  1610.            &normalBigSolidBitmap,
  1611.            silverP_bits, silverP_m_bits, silverP_l_bits);
  1612.     ReadBitmap(appData.normalPRookBitmap, &normalPRookBitmap,
  1613.            &normalBigSolidBitmap,
  1614.            rookP_bits, rookP_m_bits, rookP_l_bits);
  1615.     ReadBitmap(appData.normalPBishopBitmap, &normalPBishopBitmap,
  1616.            &normalBigSolidBitmap,
  1617.            bishopP_bits, bishopP_m_bits, bishopP_l_bits);
  1618.     ReadBitmap(appData.normalKingBitmap, &normalKingBitmap,
  1619.            &normalBigSolidBitmap,
  1620.            king_bits, king_m_bits, king_l_bits);
  1621.  
  1622. #endif
  1623.  
  1624.     XSynchronize(xDisplay, False);    /* Work-around for xlib/xt
  1625.                        buffering bug */
  1626. }           
  1627.         
  1628.  
  1629.                     
  1630. int 
  1631. ReadBitmapFile(display, d, filename, width_return,
  1632.      height_return, bitmap_return,
  1633.      x_hot_return, y_hot_return)
  1634.          Display *display;
  1635.          Drawable d;
  1636.          char *filename;
  1637.          unsigned int *width_return, *height_return;
  1638.          Pixmap *bitmap_return;
  1639.          int *x_hot_return, *y_hot_return;
  1640. { 
  1641.   int n;                
  1642.   if ((n = XReadBitmapFile(display, d, filename,
  1643.         width_return, height_return, bitmap_return, x_hot_return, y_hot_return)) 
  1644.               != BitmapSuccess)
  1645.     return(n);
  1646.   else
  1647.     { 
  1648.       /* transform a 1 plane pixmap to a k plane pixmap */
  1649.       return(BitmapSuccess);
  1650.     }
  1651. }
  1652.  
  1653.  
  1654. void
  1655. ReadBitmap(name, pm, qm, small_bits, medium_bits, large_bits)
  1656.     String name;
  1657.     Pixmap *pm, *qm;
  1658.     char small_bits[], medium_bits[], large_bits[];
  1659. {
  1660.     int x_hot, y_hot;
  1661.     u_int w, h;    
  1662.  
  1663.     if (name == NULL || ReadBitmapFile(xDisplay, xBoardWindow, name,
  1664.         &w, &h, pm, &x_hot, &y_hot) != BitmapSuccess
  1665.         || w != squareSize || h != squareSize) {
  1666.         unsigned long fg, bg;
  1667.         unsigned int depth;
  1668.         depth = DisplayPlanes(xDisplay, xScreen);
  1669.         if ( appData.monoMode ) {
  1670.           fg = XBlackPixel(xDisplay, xScreen);
  1671.           bg = XWhitePixel(xDisplay, xScreen);
  1672.         } else if ( qm == NULL ) {
  1673.           fg = appData.whitePieceColor;
  1674.           bg = appData.lightSquareColor;
  1675.         } else {
  1676.           fg = (black_pixel_is_zero ? 0 : ~0);
  1677.           bg = (black_pixel_is_zero ? ~0 : 0);
  1678.         };
  1679.         switch (boardSize) {
  1680.               case Large:
  1681.             *pm = XCreatePixmapFromBitmapData(xDisplay, xBoardWindow,
  1682.                   large_bits, squareSize, squareSize,
  1683.                   fg, bg, depth);
  1684.             break;
  1685.               case Medium:
  1686.             *pm = XCreatePixmapFromBitmapData(xDisplay, xBoardWindow,
  1687.                   medium_bits, squareSize, squareSize,
  1688.                   fg, bg, depth);
  1689.             break;
  1690.               case Small:
  1691.             *pm = XCreatePixmapFromBitmapData(xDisplay, xBoardWindow,
  1692.                   small_bits, squareSize, squareSize,
  1693.                   fg, bg, depth);
  1694.             break;
  1695.         }
  1696.     }     
  1697. }                  
  1698.  
  1699.  
  1700.  
  1701. void
  1702. CreateGrid()
  1703. {
  1704.     int i, offset;
  1705.  
  1706.     offset = 2 * (squareSize + LINE_GAP);
  1707.  
  1708.     for (i = 0; i < BOARD_SIZE + 1; i++) {
  1709.         gridSegments[i].x1 = offset;
  1710.                 gridSegments[i + BOARD_SIZE + 1].y1 = 0;
  1711.         gridSegments[i].y1 = gridSegments[i].y2
  1712.             = LINE_GAP / 2 + (i * (squareSize + LINE_GAP));
  1713.         gridSegments[i].x2 = LINE_GAP + BOARD_SIZE *
  1714.                 (squareSize + LINE_GAP) + offset;
  1715.         gridSegments[i + BOARD_SIZE + 1].x1 =
  1716.         gridSegments[i + BOARD_SIZE + 1].x2 = LINE_GAP / 2
  1717.             + (i * (squareSize + LINE_GAP)) + offset;
  1718.         gridSegments[i + BOARD_SIZE + 1].y2 =
  1719.             BOARD_SIZE * (squareSize + LINE_GAP);
  1720.     }
  1721. }               
  1722.  
  1723.  
  1724.  
  1725. void
  1726. CreatePieceMenus()
  1727. {
  1728.     int i;
  1729.     Widget entry;
  1730.     Arg args[1];
  1731.     ChessSquare selection;
  1732.     
  1733.     XtSetArg(args[0], XtNlabel, "Black");
  1734.     blackPieceMenu = XtCreatePopupShell("menuW", simpleMenuWidgetClass,
  1735.                        boardWidget, args, 1);
  1736.     for (i = 0; i < PIECE_MENU_SIZE; i++) {
  1737.         String item = pieceMenuStrings[i];
  1738.  
  1739.         if (strcmp(item, "----") == 0) {
  1740.             entry = XtCreateManagedWidget(item, smeLineObjectClass,
  1741.                               blackPieceMenu, NULL, 0);
  1742.         } else {
  1743.             entry = XtCreateManagedWidget(item, smeBSBObjectClass,
  1744.                               blackPieceMenu, NULL, 0);
  1745.             selection = pieceMenuTranslation[0][i];
  1746.             XtAddCallback(entry, XtNcallback,
  1747.                       (XtCallbackProc) PieceMenuSelect,
  1748.                       (caddr_t) selection);
  1749.             if (selection == BlackPawn) {
  1750.                 XtSetArg(args[0], XtNpopupOnEntry, entry);
  1751.                 XtSetValues(blackPieceMenu, args, 1);
  1752.             }
  1753.         }
  1754.     }
  1755.  
  1756.     XtSetArg(args[0], XtNlabel, "White");
  1757.     whitePieceMenu = XtCreatePopupShell("menuB", simpleMenuWidgetClass,
  1758.                        boardWidget, args, 1);
  1759.     for (i = 0; i < PIECE_MENU_SIZE; i++) {
  1760.         String item = pieceMenuStrings[i];
  1761.  
  1762.         if (strcmp(item, "----") == 0) {
  1763.             entry = XtCreateManagedWidget(item, smeLineObjectClass,
  1764.                               whitePieceMenu, NULL, 0);
  1765.         } else {
  1766.             entry = XtCreateManagedWidget(item, smeBSBObjectClass,
  1767.                               whitePieceMenu, NULL, 0);
  1768.             selection = pieceMenuTranslation[1][i];
  1769.             XtAddCallback(entry, XtNcallback,
  1770.                       (XtCallbackProc) PieceMenuSelect,
  1771.                       (caddr_t) selection);
  1772.             if (selection == WhitePawn) {
  1773.                 XtSetArg(args[0], XtNpopupOnEntry, entry);
  1774.                 XtSetValues(whitePieceMenu, args, 1);
  1775.             }
  1776.         }
  1777.     }
  1778.  
  1779.     XtRegisterGrabAction(PieceMenuPopup, True,
  1780.                  (unsigned)(ButtonPressMask|ButtonReleaseMask),
  1781.                  GrabModeAsync, GrabModeAsync);
  1782. }    
  1783.  
  1784. void
  1785. PieceMenuPopup(w, event, params, num_params)
  1786.     Widget w;
  1787.     XEvent *event;
  1788.         String *params;
  1789.         Cardinal *num_params;
  1790. {
  1791.     if (event->type != ButtonPress) return;
  1792.     if (gameMode != EditPosition) return;
  1793.     if (((pmFromX = EventToXSquare(event->xbutton.x)) < 1) ||
  1794.        (pmFromX > BOARD_SIZE+2) ||
  1795.         ((pmFromY = EventToSquare(event->xbutton.y)) < 0)) {
  1796.         pmFromX = pmFromY = -1;
  1797.         return;
  1798.     }
  1799.     if (flipView)
  1800.       pmFromX = BOARD_SIZE + 3 - pmFromX;
  1801.     else
  1802.       pmFromY = BOARD_SIZE - 1 - pmFromY;
  1803.  
  1804.     XtPopupSpringLoaded(XtNameToWidget(boardWidget, params[0]));
  1805. }
  1806.  
  1807. static void
  1808. PieceMenuSelect(w, piece, junk)
  1809.      Widget w;
  1810.      ChessSquare piece;
  1811.      caddr_t junk;
  1812. {
  1813.     if (pmFromX < 0 || pmFromY < 0) return;
  1814.     if (off_board(pmFromX) ) {
  1815.       int i, c;
  1816.       switch (piece) {
  1817.         case ClearBoard:
  1818.               break;
  1819.         case BlackPlay:
  1820.               break;
  1821.         case WhitePlay:
  1822.               break;
  1823.             default: 
  1824.                i = pieceToCatchedIndex[piece];
  1825.         c = (piece >= WhitePawn );
  1826.         catches[0][c][i]++;
  1827.         UpdateCatched(c, i, True, False, 0);
  1828.         XSync(xDisplay, False);
  1829.         return;
  1830.           }
  1831.     }
  1832.     pmFromX -= 2;
  1833.     switch (piece) {
  1834.           case ClearBoard:
  1835.         for (pmFromY = 0; pmFromY < BOARD_SIZE; pmFromY++)
  1836.           for (pmFromX = 0; pmFromX < BOARD_SIZE; pmFromX++) {
  1837.               boards[0][pmFromY][pmFromX] = EmptySquare;
  1838.               DrawSquare(pmFromY, pmFromX, EmptySquare);
  1839.           }
  1840.         ClearCatches(catches[0]);
  1841.         UpdateCatched(0,0,False,True, 0);
  1842.         UpdateCatched(1,0,False,True, 0);
  1843.         break;
  1844.  
  1845.           case BlackPlay:  /*not currently on menu*/
  1846.         SetBlackToPlay();
  1847.         break;
  1848.  
  1849.           case WhitePlay:  /*not currently on menu*/
  1850.         SetWhiteToPlay();
  1851.         break;
  1852.  
  1853.           default:
  1854.         boards[0][pmFromY][pmFromX] = piece;
  1855.         DrawSquare(pmFromY, pmFromX, piece);
  1856.         break;
  1857.     }
  1858.     XSync(xDisplay, False);
  1859. }
  1860.  
  1861. static void
  1862. SetBlackToPlay()
  1863. {
  1864.     int saveCM;
  1865.  
  1866.     if (gameMode != EditPosition) return;
  1867.     whitePlaysFirst = False;
  1868.     saveCM = currentMove;
  1869.     currentMove = 0;  /*kludge*/
  1870.     DisplayClocks(ReDisplayTimers);
  1871.     currentMove = saveCM;
  1872. }
  1873.  
  1874. static void
  1875. SetWhiteToPlay()
  1876. {
  1877.     int saveCM;
  1878.  
  1879.     if (gameMode != EditPosition) return;
  1880.     whitePlaysFirst = True;
  1881.     saveCM = currentMove;
  1882.     currentMove = 1;  /*kludge*/
  1883.     DisplayClocks(ReDisplayTimers);
  1884.     currentMove = saveCM;
  1885. }
  1886.  
  1887. /*
  1888.  * If the user selects on a border boundary or off the board, return failure.
  1889.  * Otherwise map the event coordinate to the square.
  1890.  */
  1891. int
  1892. EventToSquare(x)
  1893.     int x;
  1894. {
  1895.     if (x < LINE_GAP)
  1896.         return -1;
  1897.     x -= LINE_GAP;
  1898.     if ((x % (squareSize + LINE_GAP)) >= squareSize)
  1899.         return -1;
  1900.     x /= (squareSize + LINE_GAP);
  1901.     if (x >= BOARD_SIZE)
  1902.         return -1;
  1903.     return x;
  1904. }
  1905.  
  1906.  
  1907.  
  1908. int
  1909. EventToXSquare(x)
  1910.     int x;
  1911. {
  1912.     if (x < LINE_GAP)
  1913.         return -1;
  1914.     x -= LINE_GAP;
  1915.     if ((x % (squareSize + LINE_GAP)) >= squareSize)
  1916.         return -1;
  1917.     x /= (squareSize + LINE_GAP);
  1918.     if (x >= BOARD_SIZE+4)
  1919.         return -1;
  1920.     return x;
  1921. }
  1922.  
  1923.  
  1924.  
  1925. ChessSquare
  1926. CharToPiece(c, p)
  1927.     int c;
  1928.     int p;
  1929. {               
  1930.     if ( p )
  1931.         switch (c) {
  1932.         default:
  1933.         case '.':    return EmptySquare;
  1934.         case 'P':    return BlackPPawn;
  1935.         case 'L':    return BlackPLance;
  1936.         case 'N':    return BlackPKnight;
  1937.         case 'S':    return BlackPSilver;
  1938.         case 'G':    return BlackGold;
  1939.         case 'R':    return BlackPRook;
  1940.         case 'B':    return BlackPBishop;
  1941.         case 'K':    return BlackKing;
  1942.         case 'p':    return WhitePPawn;
  1943.         case 'l':    return WhitePLance;
  1944.         case 'n':    return WhitePKnight;
  1945.         case 's':    return WhitePSilver;
  1946.         case 'g':    return WhiteGold;
  1947.         case 'r':    return WhitePRook;
  1948.         case 'b':    return WhitePBishop;
  1949.         case 'k':    return WhiteKing;
  1950.         }
  1951.     else
  1952.         switch (c) {
  1953.         default:
  1954.         case '.':    return EmptySquare;
  1955.         case 'P':    return BlackPawn;
  1956.         case 'L':    return BlackLance;
  1957.         case 'N':    return BlackKnight;
  1958.         case 'S':    return BlackSilver;
  1959.         case 'G':    return BlackGold;
  1960.         case 'R':    return BlackRook;
  1961.         case 'B':    return BlackBishop;
  1962.         case 'K':    return BlackKing;
  1963.         case 'p':    return WhitePawn;
  1964.         case 'l':    return WhiteLance;
  1965.         case 'n':    return WhiteKnight;
  1966.         case 's':    return WhiteSilver;
  1967.         case 'g':    return WhiteGold;
  1968.         case 'r':    return WhiteRook;
  1969.         case 'b':    return WhiteBishop;
  1970.         case 'k':    return WhiteKing;
  1971.         }                              
  1972.  
  1973. }
  1974.  
  1975.  
  1976. /* Convert coordinates to normal algebraic notation.
  1977.    promoPiece must be '\000' if not a promotion.
  1978. */
  1979. ChessMove
  1980. MakeAlg(fromX, fromY, toX, toY, promoPiece, currentBoardIndex, out)
  1981.      int fromX, fromY, toX, toY;
  1982.      char promoPiece;
  1983.      int currentBoardIndex;
  1984.      char out[MOVE_LEN];
  1985. {
  1986.     ChessSquare piece;
  1987.     ChessMove ret;
  1988.     char *outp = out;
  1989.     int i;
  1990.  
  1991.         if ( fromX > 80 ) {
  1992.         ChessSquare piece;
  1993.         piece = (fromX - 81);
  1994.                 *outp++ = catchedIndexToChar[piece];
  1995.                 *outp++ = '*';
  1996.         *outp++ = '9' - toX;
  1997.         *outp++ = 'i' - toY;
  1998.         *outp++ = '\000';
  1999.                 return (BLACK_ON_MOVE ? BlackDrop : WhiteDrop);
  2000.     } else {
  2001.         *outp++ = '9' - fromX;
  2002.         *outp++ = 'i' - fromY;
  2003.         *outp++ = '9' - toX;
  2004.         *outp++ = 'i' - toY;
  2005.         *outp++ = promoPiece;
  2006.         *outp++ = '\000';
  2007.                 if ( promoPiece == '\000' )
  2008.                    return NormalMove;
  2009.         else
  2010.            return (BLACK_ON_MOVE ? BlackPromotion : WhitePromotion);
  2011.     }
  2012.  
  2013. }
  2014.  
  2015. void
  2016. DrawSquare(row, column, piece)
  2017.     int row, column;
  2018.     ChessSquare piece;
  2019. {
  2020.     int square_color, x, y, direction, font_ascent, font_descent;
  2021.     char string[2];
  2022.     XCharStruct overall;
  2023.  
  2024.         int offset;
  2025.  
  2026.     offset = 2 * (squareSize + LINE_GAP);
  2027.  
  2028.     if (flipView) {
  2029.         x = LINE_GAP + ((BOARD_SIZE-1)-column) * 
  2030.             (squareSize + LINE_GAP) + offset;
  2031.         y = LINE_GAP + row * (squareSize + LINE_GAP);
  2032.     } else {
  2033.         x = LINE_GAP + column * (squareSize + LINE_GAP) + offset;
  2034.         y = LINE_GAP + ((BOARD_SIZE-1)-row) * 
  2035.             (squareSize + LINE_GAP);
  2036.     }
  2037.  
  2038.     square_color = ((column + row) % 2) == 1;
  2039.  
  2040.     if (piece == EmptySquare) {
  2041.         if ( column < 0 || column >= BOARD_SIZE )
  2042.           XFillRectangle(xDisplay, xBoardWindow,
  2043.                      wbPieceGC,
  2044.                      x, y, squareSize, squareSize);
  2045.         else
  2046.           XFillRectangle(xDisplay, xBoardWindow,
  2047.                      square_color ? lightSquareGC : darkSquareGC,
  2048.                      x, y, squareSize, squareSize);
  2049.     } else if (appData.monoMode || column < 0 || column >= BOARD_SIZE) {
  2050.         if (square_color)
  2051.           XCopyArea(xDisplay, ((int) piece < (int) WhitePawn) ^ flipView
  2052.                  ? *pieceToNormal[(int) piece]
  2053.                  : *pieceToReverse[(int) piece],
  2054.                  xBoardWindow, 
  2055.                  (appData.monoMode ? wbPieceGC : wlPieceGC), 
  2056.                  0, 0,
  2057.                  squareSize, squareSize, x, y);
  2058.         else
  2059.           XCopyArea(xDisplay, ((int) piece < (int) WhitePawn) ^ flipView
  2060.                  ? *pieceToNormal[(int) piece]
  2061.                  : *pieceToReverse[(int) piece],
  2062.                  xBoardWindow, 
  2063.                  (appData.monoMode ? bwPieceGC : wlPieceGC), 
  2064.                  0, 0,
  2065.                  squareSize, squareSize, x, y);
  2066.     } else {          
  2067.         if (square_color) {
  2068.           XCopyArea(xDisplay, ((int) piece < (int) WhitePawn) ^ flipView
  2069.                  ? *pieceToNormalSolid[(int) piece]
  2070.                  : *pieceToReverseSolid[(int) piece],
  2071.                  xBoardWindow, 
  2072.                  wlPieceGC, 
  2073.                  0, 0,
  2074.                  squareSize, squareSize, x, y);
  2075.           XCopyArea(xDisplay, ((int) piece < (int) WhitePawn) ^ flipView
  2076.                  ? *pieceToNormal[(int) piece]
  2077.                  : *pieceToReverse[(int) piece],
  2078.                  xBoardWindow, 
  2079.                  charPieceGC, 
  2080.                  0, 0,
  2081.                  squareSize, squareSize, x, y);
  2082.         } else {
  2083.           XCopyArea(xDisplay, ((int) piece < (int) WhitePawn) ^ flipView
  2084.                  ? *pieceToNormalSolid[(int) piece]
  2085.                  : *pieceToReverseSolid[(int) piece],
  2086.                  xBoardWindow, 
  2087.                  wlPieceGC, 
  2088.                  0, 0,
  2089.                  squareSize, squareSize, x, y);
  2090.           XCopyArea(xDisplay, ((int) piece < (int) WhitePawn) ^ flipView
  2091.                  ? *pieceToNormal[(int) piece]
  2092.                  : *pieceToReverse[(int) piece],
  2093.                  xBoardWindow, 
  2094.                  charPieceGC, 
  2095.                  0, 0,
  2096.                  squareSize, squareSize, x, y);
  2097.         }
  2098.     }
  2099.         string[1] = '\000';
  2100.     if (appData.showCoords && column >= 0 && column < 9 && row == (flipView ? 8 : 0)) {
  2101.         string[0] = '9' - column;
  2102.         XTextExtents(coordFont, string, 1, &direction, 
  2103.         &font_ascent, &font_descent, &overall);
  2104.         if (appData.monoMode) {
  2105.            XDrawImageString(xDisplay, xBoardWindow, coordGC,
  2106.             x + squareSize - overall.width - 2, 
  2107.             y + squareSize - font_descent - 1, string, 1);
  2108.         } else {
  2109.            XDrawString(xDisplay, xBoardWindow, coordGC,
  2110.             x + squareSize - overall.width - 2, 
  2111.             y + squareSize - font_descent - 1, string, 1);
  2112.         }
  2113.     }
  2114.     if (appData.showCoords && row >= 0 && row < 9 && column == (flipView ? 8 : 0)) {
  2115.         string[0] = 'i' - row;
  2116.         XTextExtents(coordFont, string, 1, &direction, 
  2117.         &font_ascent, &font_descent, &overall);
  2118.         if (appData.monoMode) {
  2119.            XDrawImageString(xDisplay, xBoardWindow, coordGC,
  2120.             x + 2, y + font_ascent + 1, string, 1);
  2121.         } else {
  2122.            XDrawString(xDisplay, xBoardWindow, coordGC,
  2123.             x + 2, y + font_ascent + 1, string, 1);
  2124.         }        
  2125.     }   
  2126. }
  2127.  
  2128. void
  2129. EventProc(widget, unused, event)
  2130.     Widget widget;
  2131.     caddr_t unused;
  2132.     XEvent *event;
  2133. {
  2134.     if (event->type == MappingNotify) {
  2135.         XRefreshKeyboardMapping((XMappingEvent *) event);
  2136.         return;
  2137.     }
  2138.  
  2139.     if (!XtIsRealized(widget))
  2140.         return;
  2141.  
  2142.     if ((event->type == ButtonPress) || (event->type == ButtonRelease))
  2143.         if (event->xbutton.button != Button1)
  2144.             return;
  2145.  
  2146.     switch (event->type) {
  2147.     case Expose:
  2148.         DrawPosition(widget, (XExposeEvent *) event);
  2149.         break;
  2150.     default:
  2151.         return;
  2152.     }
  2153. }
  2154.  
  2155. /*
  2156.  * event handler for redrawing the board
  2157.  */
  2158. void
  2159. DrawPosition(w, event)
  2160.     Widget w;
  2161.     XExposeEvent *event;
  2162. {
  2163.     Arg args[1];
  2164.     int i, j;
  2165.         if (!appData.Iconic){
  2166.         XtSetArg(args[0], XtNiconic, False);
  2167.         XtSetValues(shellWidget, args, 1);
  2168.         }
  2169.  
  2170.     /*
  2171.      * It would be simpler to clear the window with XClearWindow()
  2172.      * but this causes a very distracting flicker.
  2173.      */
  2174.     XDrawSegments(xDisplay, xBoardWindow, lineGC,
  2175.         gridSegments, (BOARD_SIZE + 1) * 2);
  2176.  
  2177.     for (i = 0; i < BOARD_SIZE; i++)
  2178.         for (j = 0; j < BOARD_SIZE; j++)
  2179.             DrawSquare(i, j, boards[currentMove][i][j]);
  2180.  
  2181.     UpdateCatched(0,0,False,True,currentMove);
  2182.     UpdateCatched(1,0,False,True,currentMove);
  2183.  
  2184.     XSync(xDisplay, False);
  2185. }
  2186.  
  2187. void
  2188. InitPosition()
  2189. {
  2190.     currentMove = forwardMostMove = 0;
  2191.     CopyBoard(boards[0], initialPosition);
  2192.         ClearCatches(catches[0]);
  2193.     
  2194.     DrawPosition(boardWidget, (XExposeEvent *) NULL);
  2195. }
  2196.  
  2197. void
  2198. CopyBoard(to, from)
  2199.     Board to, from;
  2200. {
  2201.     int i, j;
  2202.  
  2203.     for (i = 0; i < BOARD_SIZE; i++)
  2204.         for (j = 0; j < BOARD_SIZE; j++)
  2205.             to[i][j] = from[i][j];
  2206. }
  2207.         
  2208.  
  2209.  
  2210. void
  2211. CopyCatches(to, from)
  2212.     Catched to, from;
  2213. {
  2214.     int i, j;
  2215.  
  2216.     for (i = 0; i < 2; i++)
  2217.         for (j = 0; j < 8; j++)
  2218.             to[i][j] = from[i][j];
  2219. }
  2220.  
  2221.  
  2222.  
  2223.  
  2224. void
  2225. SendCurrentBoard(fp)
  2226.     FILE *fp;
  2227. {
  2228.     SendBoard(fp, boards[currentMove], catches[currentMove]);
  2229. }
  2230.  
  2231. void
  2232. SendBoard(fp, board, catches)
  2233.     FILE *fp;
  2234.         Board board;
  2235.     Catched catches;
  2236. {
  2237.     char message[MSG_SIZ];
  2238.     ChessSquare *bp;
  2239.     int i, j;
  2240.  
  2241.     SendToProgram("edit\n", fp);
  2242.     SendToProgram("#\n", fp);
  2243.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  2244.         bp = &board[i][0];
  2245.         for (j = 0; j < BOARD_SIZE; j++, bp++) {
  2246.             if ((int) *bp < (int) WhitePawn) {
  2247.                 sprintf(message, "%c%c%c\n",
  2248.                     pieceToChar[(int) *bp],
  2249.                     '9' - j, 'i' - i);
  2250.                 SendToProgram(message, fp);
  2251.             }
  2252.         }
  2253.     }
  2254.  
  2255.     for ( i = 0; i <= 7; i++ ) {
  2256.         int n;
  2257.         for ( n = catches[0][i]; n > 0; n-- ) {
  2258.             sprintf(message, "%c*\n",
  2259.                 catchedIndexToChar[i]);
  2260.                 SendToProgram(message, fp);
  2261.         };
  2262.     }
  2263.  
  2264.     SendToProgram("c\n", fp);
  2265.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  2266.         bp = &board[i][0];
  2267.         for (j = 0; j < BOARD_SIZE; j++, bp++) {
  2268.             if (((int) *bp != (int) EmptySquare)
  2269.                 && ((int) *bp >= (int) WhitePawn)) {
  2270.                 sprintf(message, "%c%c%c\n",
  2271.                     pieceToChar[(int) *bp -
  2272.                             (int) WhitePawn],
  2273.                     '9' - j, 'i' - i);
  2274.                 SendToProgram(message, fp);
  2275.             }
  2276.         }
  2277.     }
  2278.  
  2279.     for ( i = 0; i <= 7; i++ ) {
  2280.         int n;
  2281.         for ( n = catches[1][i]; n > 0; n-- ) {
  2282.             sprintf(message, "%c*\n",
  2283.                 catchedIndexToChar[i]);
  2284.                 SendToProgram(message, fp);
  2285.         };
  2286.     }
  2287.  
  2288.     SendToProgram(".\n", fp);
  2289. }
  2290.  
  2291.  
  2292.  
  2293.  
  2294.  
  2295.  
  2296. static
  2297. int
  2298. PromotionPossible (fromY, toY, piece)
  2299.     int fromY, toY;
  2300.     ChessSquare piece;
  2301. { 
  2302.   if ( (int) piece < (int) WhitePawn ) {
  2303.     if ( fromY < 6 && toY < 6 ) return(False);
  2304.   } else {
  2305.     if ( fromY > 2 && toY > 2 ) return(False);
  2306.   };    
  2307.  
  2308.   return piecePromotable[(int) piece];
  2309.  
  2310. }
  2311.  
  2312.  
  2313. static
  2314. void
  2315. ShowCount (row, column, n)
  2316.    int row, column, n;
  2317. {
  2318.    int offset = 2 * (squareSize + LINE_GAP);
  2319.    int x, y, direction, font_ascent, font_descent;
  2320.    char string[2];
  2321.    XCharStruct overall;
  2322.  
  2323.    DrawSquare (row, column, EmptySquare);
  2324.    if ( n <= 1 ) {
  2325.      return;
  2326.    };
  2327.  
  2328.    if (flipView) {
  2329.           x = LINE_GAP + ((BOARD_SIZE-1)-column) *
  2330.               (squareSize + LINE_GAP) + offset;
  2331.           y = LINE_GAP + row * (squareSize + LINE_GAP);
  2332.    } else {
  2333.           x = LINE_GAP + column * (squareSize + LINE_GAP) + offset;
  2334.           y = LINE_GAP + ((BOARD_SIZE-1)-row) *
  2335.               (squareSize + LINE_GAP);
  2336.    }
  2337.  
  2338.    x -= squareSize / 2;
  2339.  
  2340.    string[1] = '\000';
  2341.  
  2342.    if ( n > 9 )
  2343.      string[0] = '*';
  2344.    else 
  2345.      string[0] = '0'+n;
  2346.  
  2347.    XTextExtents(coordFont, string, 1, &direction,
  2348.                 &font_ascent, &font_descent, &overall);
  2349.    if (appData.monoMode) {
  2350.       XDrawImageString(xDisplay, xBoardWindow, coordGC,
  2351.            x + squareSize - overall.width - 2,
  2352.            y + squareSize - font_descent - 1, string, 1);
  2353.    } else {
  2354.       XDrawString(xDisplay, xBoardWindow, coordGC,
  2355.            x + squareSize - overall.width - 2,
  2356.            y + squareSize - font_descent - 1, string, 1);
  2357.    }
  2358. }
  2359.  
  2360.  
  2361. void UpdateCatched (Color,Figure,Drop,DropAll,currentMove)
  2362.  
  2363. int Color,Figure,Drop,DropAll,currentMove;
  2364.  
  2365. {
  2366.  
  2367.   int n,F,C;
  2368.   int x,y;
  2369.  
  2370.   /* Determine first row and column. */
  2371.  
  2372.   if ( Color ) { 
  2373.     x = -1; y = BOARD_SIZE-1;
  2374.   } else {
  2375.     x = BOARD_SIZE; y = 0;
  2376.   }; 
  2377.  
  2378.  
  2379.   if ( DropAll )
  2380.     n = 0;
  2381.   else
  2382.     n = catches[currentMove][Color][Figure];
  2383.  
  2384.   /* Update the display for captured pieces
  2385.      if no piece of the dropped type is there (Drop && n==1)
  2386.      or if a piece type is removed (NOT Drop && n==0).
  2387.      In the other cases update only the count. */
  2388.  
  2389.   if ( DropAll || (Drop && (n==1)) || ((! Drop) && (n==0)) ) {
  2390.     /* show all captured pieces */
  2391.     n = 0;
  2392.     for ( F = pawn; F<=king; F++ ) {
  2393.       int c;
  2394.       if ( (c=catches[currentMove][Color][F])>0 ) {
  2395.         n++;
  2396.     DrawSquare(y, x, catchedIndexToPiece[Color][F]); 
  2397.         ShowCount(y, Color ? (x-1) : (x+1), c);
  2398.         if ( Color ) y--; else y++;
  2399.       };
  2400.     };
  2401.     if ( DropAll ) {
  2402.       for ( ; n < 9; n++ ) {
  2403.         DrawSquare(y, x, EmptySquare);
  2404.         ShowCount(y, Color ? (x-1) : (x+1), 0);
  2405.         if ( Color ) y--; else y++;
  2406.       }
  2407.     } else if ( ! Drop ) {
  2408.       /* remove one line ! */
  2409.       DrawSquare(y, x, EmptySquare);
  2410.       ShowCount(y, Color ? (x-1) : (x+1), 0);
  2411.     };
  2412.   } else {
  2413.     /* show the actual count */
  2414.     for ( F = pawn; F <= Figure-1; F++ ) {
  2415.       if ( catches[currentMove][Color][F] > 0 ) {
  2416.         if ( Color ) y--; else y++;
  2417.       };
  2418.     };
  2419.    ShowCount(y, Color ? (x-1) : (x+1), n); 
  2420.   };
  2421.  
  2422. };
  2423.  
  2424.  
  2425. static
  2426. int
  2427. PieceOfCatched (color, x, y, currentMove)
  2428.     int color, x, y, currentMove;
  2429. {
  2430.   int F, n;
  2431.  
  2432.   if ( color ) {
  2433.     if ( x != 1 ) return (no_piece);
  2434.     y = 8 - y;
  2435.   } else {
  2436.     if ( x != 11 ) return (no_piece);
  2437.   };
  2438.  
  2439.   for ( F = pawn, n = 0; F <= king; F++ ) {
  2440.     if ( catches[currentMove][color][F] > 0 ) {
  2441.     if ( n == y ) return (F);
  2442.     n++;
  2443.     };
  2444.   };
  2445.  
  2446.   return (no_piece);
  2447. }
  2448.  
  2449.  
  2450.  
  2451.  
  2452.  
  2453. /*
  2454.  * event handler for parsing user moves
  2455.  */
  2456. void
  2457. HandleUserMove(w, event)
  2458.     Widget w;
  2459.     XEvent *event;
  2460. {
  2461.     ChessMove move_type;
  2462.     ChessSquare from_piece;
  2463.     int to_x, to_y;
  2464.  
  2465.     if ((w != boardWidget) || (matchMode != MatchFalse))
  2466.         return;
  2467.  
  2468.     if (promotionUp) {
  2469.         XtPopdown(promotionShell);
  2470.         XtDestroyWidget(promotionShell);
  2471.         promotionUp = False;
  2472.         fromX = fromY = -1;
  2473.     }
  2474.  
  2475.     switch (gameMode) {
  2476.           case EndOfGame:
  2477.           case PlayFromGameFile:
  2478.           case TwoMachinesPlay:
  2479.         return;
  2480.           case MachinePlaysBlack:
  2481.         if (BLACK_ON_MOVE)
  2482.             return;
  2483.         break;
  2484.           case MachinePlaysWhite:
  2485.         if (!BLACK_ON_MOVE)
  2486.             return;
  2487.         break;
  2488.           default:
  2489.         break;
  2490.     }
  2491.  
  2492.     switch (event->type) {
  2493.           case ButtonPress:
  2494.         if ((fromX >= 0) || (fromY >= 0))
  2495.           return;
  2496.         if (((fromX = EventToXSquare(event->xbutton.x)) < 1) ||
  2497.                     (fromX > BOARD_SIZE+2) ||
  2498.             ((fromY = EventToSquare(event->xbutton.y)) < 0)) {
  2499.             fromX = fromY = -1;
  2500.             return;
  2501.         }
  2502.         if (flipView)
  2503.           fromX = BOARD_SIZE + 3 - fromX;
  2504.         else
  2505.           fromY = BOARD_SIZE - 1 - fromY;
  2506.         break;
  2507.  
  2508.           case ButtonRelease:
  2509.         if ((fromX < 0) || (fromY < 0)) return;
  2510.  
  2511.         if (((to_x = EventToXSquare(event->xbutton.x)) < 1)
  2512.                 || (to_x > BOARD_SIZE+2)
  2513.             || ((to_y = EventToSquare(event->xbutton.y)) < 0)) {
  2514.             if (gameMode == EditPosition)
  2515.             if ( !off_board(fromX) )
  2516.             { 
  2517.               fromX -= 2;
  2518.               boards[0][fromY][fromX] = EmptySquare;
  2519.               DrawSquare(fromY, fromX, EmptySquare);
  2520.               XSync(xDisplay, False);
  2521.             }
  2522.             fromX = fromY = -1;
  2523.             return;
  2524.         }
  2525.         if (flipView)
  2526.             to_x = BOARD_SIZE + 3 - to_x;
  2527.         else
  2528.             to_y = BOARD_SIZE - 1 - to_y;
  2529.  
  2530.         if ((fromX == to_x) && (fromY == to_y)) {
  2531.             fromX = fromY = -1;
  2532.             return;
  2533.         }
  2534.  
  2535.         if (gameMode == EditPosition) {
  2536.                   ChessSquare piece;
  2537.           if ( off_board(fromX) ) {
  2538.             /* Remove a catched piece */
  2539.             int c = ((fromX < 5) ^ flipView);
  2540.             int i = PieceOfCatched(c,fromX,fromY,0);
  2541.             if ( i == no_piece ) {
  2542.                 fromX = fromY = -1;
  2543.                  return;
  2544.             } else {
  2545.                 piece = catchedIndexToPiece[c][i];
  2546.                         catches[0][c][i]--;
  2547.                         UpdateCatched(c, i, False, False, 0);
  2548.             }
  2549.           } else {
  2550.             /* remove piece from board field */
  2551.             fromX -= 2;
  2552.             piece = boards[0][fromY][fromX];
  2553.             boards[0][fromY][fromX] = EmptySquare;
  2554.             DrawSquare(fromY, fromX, EmptySquare);
  2555.           }
  2556.           if ( !off_board(to_x) ) {
  2557.                 /* drop piece to board field */    
  2558.                         ChessSquare catched_piece;
  2559.                 to_x -= 2;
  2560.             catched_piece = boards[0][to_y][to_x];
  2561.                         if ( catched_piece != EmptySquare ) {
  2562.               /* put piece to catched pieces */
  2563.                             int i = pieceToCatchedIndex[catched_piece];
  2564.                             int c = (catched_piece < WhitePawn );
  2565.                             catches[0][c][i]++;
  2566.                             UpdateCatched(c, i, True, False, 0);
  2567.                         };
  2568.             /* place moved piece */
  2569.             boards[0][to_y][to_x] = piece;
  2570.             DrawSquare(to_y, to_x, piece);
  2571.           }
  2572.           fromX = fromY = -1;
  2573.           XSync(xDisplay, False);
  2574.           return;
  2575.         }
  2576.         
  2577.         if ( off_board(fromX) ) {
  2578.             int c = BLACK_ON_MOVE ? 0 : 1;
  2579.             int piece = PieceOfCatched(c,fromX,fromY,currentMove);
  2580.             if ( piece == no_piece ) {
  2581.                 fromX = fromY = -1;
  2582.                  return;
  2583.             } else {
  2584.                 fromX = fromY = piece + 81;
  2585.                 to_x -= 2;
  2586.                 move_type = BLACK_ON_MOVE ? BlackDrop : WhiteDrop;
  2587.                   MakeMove(&move_type, fromX, fromY, to_x, to_y);
  2588.                   FinishUserMove(move_type, to_x, to_y);
  2589.                   break;
  2590.             };
  2591.         } else if ( off_board(to_x) ) {
  2592.             fromX = fromY = -1;
  2593.             return;
  2594.                 } else {
  2595.           fromX -= 2; to_x -= 2;
  2596.           from_piece = boards[currentMove][fromY][fromX];
  2597.           if ( PromotionPossible(fromY, to_y, from_piece) ) {
  2598.               PromotionPopUp(from_piece, to_x, to_y);
  2599.             return;
  2600.           }
  2601.           move_type = NormalMove;
  2602.           MakeMove(&move_type, fromX, fromY, to_x, to_y);
  2603.           FinishUserMove(move_type, to_x, to_y);
  2604.           break;
  2605.         }
  2606.     }
  2607. }
  2608.  
  2609. void
  2610. FinishUserMove(move_type, to_x, to_y)
  2611.          ChessMove move_type;
  2612.          int to_x, to_y;
  2613. {
  2614.     char user_move[MSG_SIZ];
  2615.  
  2616.     switch (move_type) {
  2617.           default:
  2618.         fprintf(stderr, "%s: internal error; bad move_type\n",
  2619.             programName);
  2620.         break;
  2621.           case BlackPromotion:
  2622.           case WhitePromotion:
  2623.         sprintf(user_move, "%c%c%c%c+\n",
  2624.             '9' - fromX, 'i' - fromY, '9' - to_x, 'i' - to_y);
  2625.         break;
  2626.           case BlackDrop:
  2627.           case WhiteDrop:
  2628.         sprintf(user_move, "%c*%c%c\n",
  2629.             catchedIndexToChar[fromX - 81],'9' - to_x, 'i' - to_y);
  2630.         break;
  2631.           case NormalMove:
  2632.         sprintf(user_move, "%c%c%c%c\n",
  2633.             '9' - fromX, 'i' - fromY, '9' - to_x, 'i' - to_y);
  2634.         break;
  2635.     }
  2636.  
  2637.     fromX = fromY = -1;
  2638.  
  2639.     Attention(firstProgramPID);
  2640.     SendToProgram(user_move, toFirstProgFP);
  2641.     strcpy(moveList[currentMove - 1], user_move);
  2642.  
  2643.     if (gameMode == PauseGame)
  2644.       PauseProc(); /* a user move restarts a paused game*/
  2645.  
  2646.     switch (gameMode) {
  2647.           case ForceMoves:
  2648.           case SetupPosition:
  2649.         break;
  2650.           case BeginningOfGame:
  2651.         if (appData.noChessProgram)
  2652.           lastGameMode = gameMode = ForceMoves;
  2653.         else
  2654.           lastGameMode = gameMode = MachinePlaysWhite;
  2655.         ModeHighlight();
  2656.         break;
  2657.           case MachinePlaysWhite:
  2658.           case MachinePlaysBlack:
  2659.           default:
  2660.         break;
  2661.     }
  2662. }
  2663.  
  2664. /* Simple parser for moves from gnuchess. */
  2665. void
  2666. ParseMachineMove(machine_move, move_type, from_x, from_y, to_x, to_y)
  2667.      char *machine_move;
  2668.      ChessMove *move_type;
  2669.      int *from_x, *from_y, *to_x, *to_y;
  2670. {               
  2671.  
  2672.  
  2673. #define no_digit(c) (c < '0' || c > '9' )
  2674.  
  2675.     {                     
  2676.                 if ( no_digit(machine_move[0]) ) {
  2677.  
  2678.           switch ( machine_move[0] ) {
  2679.             case 'P': *from_x = 81; break;
  2680.             case 'L': *from_x = 82; break;
  2681.             case 'N': *from_x = 83; break;
  2682.             case 'S': *from_x = 84; break;
  2683.             case 'G': *from_x = 85; break;
  2684.             case 'B': *from_x = 86; break;
  2685.             case 'R': *from_x = 87; break;
  2686.             case 'K': *from_x = 88; break;
  2687.                         default: *from_x = -1;
  2688.           };
  2689.           *from_y = *from_x;
  2690.           *to_x   = '9' - machine_move[2];
  2691.           *to_y   = 'i' - machine_move[3];
  2692.  
  2693.         } else {
  2694.  
  2695.           *from_x = '9' - machine_move[0] ;
  2696.           *from_y = 'i' - machine_move[1];
  2697.           *to_x = '9' - machine_move[2];
  2698.           *to_y = 'i' - machine_move[3];
  2699.  
  2700.           switch (machine_move[4]) {
  2701.               case '+':
  2702.             *move_type = BLACK_ON_MOVE ?
  2703.               BlackPromotion : WhitePromotion;
  2704.             break;
  2705.               default:
  2706.             *move_type = NormalMove;
  2707.             break;
  2708.           }
  2709.         }          
  2710.     }
  2711. }
  2712.  
  2713. void
  2714. HandleMachineMove(message, fp)
  2715.     char *message;
  2716.         FILE *fp;
  2717. {
  2718.     char machine_move[MSG_SIZ], buf1[MSG_SIZ], buf2[MSG_SIZ];
  2719.     int i, j, from_x, from_y, to_x, to_y;
  2720.     ChessMove move_type;
  2721.  
  2722.     maybeThinking = False;
  2723.  
  2724.     if (strncmp(message, "warning:", 8) == 0) {
  2725.         DisplayMessage(message);
  2726.         return;
  2727.     }
  2728.  
  2729.     /*
  2730.      * If chess program startup fails, exit with an error message.
  2731.      * Attempts to recover here are futile.
  2732.      */
  2733.     if ((StrStr(message, "unknown host") != NULL)
  2734.         || (StrStr(message, "No remote directory") != NULL)
  2735.         || (StrStr(message, "not found") != NULL)
  2736.         || (StrStr(message, "No such file") != NULL)
  2737.         || (StrStr(message, "Permission denied") != NULL)) {
  2738.         fprintf(stderr,
  2739.             "%s: failed to start chess program %s on %s: %s\n",
  2740.             programName,
  2741.             fp == fromFirstProgFP ? appData.firstChessProgram
  2742.                 : appData.secondChessProgram,
  2743.             fp == fromFirstProgFP ? appData.firstHost
  2744.                 : appData.secondHost,
  2745.             message);
  2746.         ShutdownChessPrograms(message);
  2747.         exit(1);
  2748.     }
  2749.  
  2750.     /*
  2751.      * If the move is illegal, cancel it and redraw the board.
  2752.      */
  2753.     if (strncmp(message, "Illegal move", 12) == 0) {
  2754.  
  2755.         if (currentMove <= (whitePlaysFirst ? 1 : 0)) return;
  2756.         if (gameMode == PlayFromGameFile) {
  2757.             /* Stop reading this game file */
  2758.             gameMode = ForceMoves;
  2759.             ModeHighlight();
  2760.         }
  2761.         currentMove--;
  2762.         if ((gameMode == PlayFromGameFile) || 
  2763.             (gameMode == ForceMoves) ||
  2764.             (gameMode == SetupPosition))
  2765.           DisplayClocks(ReDisplayTimers);
  2766.         else
  2767.           DisplayClocks(SwitchTimers);
  2768.         sprintf(buf1, "Illegal move: %s", parseList[currentMove]);
  2769.         DisplayMessage(buf1);
  2770.  
  2771.         /*
  2772.          * Only redraw the squares that have changed.
  2773.          */
  2774.         for (i = 0; i < BOARD_SIZE; i++)
  2775.           for (j = 0; j < BOARD_SIZE; j++) {
  2776.               if (boards[currentMove][i][j] !=
  2777.                   boards[currentMove + 1][i][j])
  2778.                 DrawSquare(i, j, boards[currentMove][i][j]);
  2779.           }
  2780.         UpdateCatched(0,0,False,True, currentMove);
  2781.         UpdateCatched(1,0,False,True, currentMove);
  2782.  
  2783.         XSync(xDisplay, False);
  2784.         return;
  2785.     }
  2786.  
  2787.     if (strncmp(message, "Hint:", 5) == 0) {
  2788.         sscanf(message, "Hint: %s", machine_move);
  2789.         ParseMachineMove(machine_move, &move_type,
  2790.                  &from_x, &from_y, &to_x, &to_y);
  2791.         if ( move_type == WhitePromotion || move_type == BlackPromotion )
  2792.           move_type = MakeAlg(from_x, from_y, to_x, to_y, '+',
  2793.                    currentMove, buf1);
  2794.         else
  2795.           move_type = MakeAlg(from_x, from_y, to_x, to_y, '\000',
  2796.                    currentMove, buf1);
  2797.         sprintf(buf2, "Hint: %s", buf1);
  2798.         DisplayMessage(buf2);
  2799.         return;
  2800.     }
  2801.  
  2802.     /*
  2803.      * win, lose or draw
  2804.      */
  2805.     if (strncmp(message, "Black", 5) == 0) {
  2806.         ShutdownChessPrograms("Black wins");
  2807.         return;
  2808.     } else if (strncmp(message, "White", 5) == 0) {
  2809.         ShutdownChessPrograms("White wins");
  2810.         return;
  2811.     } else if (strncmp(message, "opponent mates!", 15) == 0) {
  2812.         switch (gameMode) {
  2813.               case MachinePlaysWhite:
  2814.             ShutdownChessPrograms("Black wins");
  2815.             break;
  2816.               case MachinePlaysBlack:
  2817.             ShutdownChessPrograms("White wins");
  2818.             break;
  2819.               case TwoMachinesPlay:
  2820.             ShutdownChessPrograms(fp == fromFirstProgFP ?
  2821.                           "Black wins" : "White wins");
  2822.             break;
  2823.               default:
  2824.             /* can't happen */
  2825.             break;
  2826.         }
  2827.         return;
  2828.     } else if (strncmp(message, "computer mates!", 15) == 0) {
  2829.         switch (gameMode) {
  2830.               case MachinePlaysWhite:
  2831.             ShutdownChessPrograms("White wins");
  2832.             break;
  2833.               case MachinePlaysBlack:
  2834.             ShutdownChessPrograms("Black wins");
  2835.             break;
  2836.               case TwoMachinesPlay:
  2837.             ShutdownChessPrograms(fp == fromFirstProgFP ?
  2838.                           "White wins" : "Black wins");
  2839.             break;
  2840.               default:
  2841.             /* can't happen */
  2842.             break;
  2843.         }
  2844.         return;
  2845.     } else if (strncmp(message, "Draw", 4) == 0) {
  2846.         ShutdownChessPrograms("Draw");
  2847.         return;
  2848.     }
  2849.  
  2850.     /*
  2851.      * normal machine reply move
  2852.      */
  2853.     maybeThinking = True;
  2854.     if (StrStr(message, "...") != NULL) {
  2855.         sscanf(message, "%s %s %s", buf1, buf2, machine_move);
  2856.         if (machine_move[0] == '\0')
  2857.             return;
  2858.     } else
  2859.         return; /* ignore noise */
  2860.  
  2861.     strcpy(moveList[currentMove], machine_move);
  2862.  
  2863.     ParseMachineMove(machine_move, &move_type, &from_x, &from_y,
  2864.              &to_x, &to_y);
  2865.  
  2866.     MakeMove(&move_type, from_x, from_y, to_x, to_y);
  2867. #if BLINK_COUNT
  2868.     if ( gameMode != TwoMachinesPlay ) 
  2869.       BlinkSquare(to_y, to_x, boards[currentMove][to_y][to_x]);
  2870. #endif
  2871.  
  2872.     switch (gameMode) {
  2873.           case PauseGame:
  2874.           case EndOfGame:
  2875.           default:
  2876.         break;
  2877.           case ForceMoves:
  2878.           case SetupPosition:
  2879.           case PlayFromGameFile:
  2880.         strncat(machine_move, "\n", 1);
  2881.         SendToProgram(machine_move, toFirstProgFP);
  2882.         break;
  2883.           case TwoMachinesPlay:
  2884.         strncat(machine_move, "\n", 1);
  2885.         if (BLACK_ON_MOVE) {
  2886.             Attention(secondProgramPID);
  2887.             SendToProgram(machine_move, toSecondProgFP);
  2888.             if (firstMove) {
  2889.                 firstMove = False;
  2890.                 SendToProgram(appData.blackString,
  2891.                           toSecondProgFP);
  2892.             }
  2893.         } else {
  2894.             Attention(firstProgramPID);
  2895.             SendToProgram(machine_move, toFirstProgFP);
  2896.             if (firstMove) {
  2897.                 firstMove = False;
  2898.                 SendToProgram(appData.whiteString,
  2899.                           toFirstProgFP);
  2900.             }
  2901.         }
  2902.         break;
  2903.     }
  2904. }
  2905.  
  2906.  
  2907. #if BLINK_COUNT
  2908.  
  2909.  
  2910. static int BlinkCount;
  2911. static int BlinkRow, BlinkCol;
  2912. static ChessSquare BlinkPiece;
  2913.  
  2914.  
  2915. void
  2916. BlinkSquareProc ()
  2917. {
  2918.    if ( BlinkCount-- ) {
  2919.     DrawSquare (BlinkRow,BlinkCol,
  2920.         (BlinkCount & 1) ? EmptySquare : BlinkPiece);
  2921.     blinkSquareXID = XtAppAddTimeOut(appContext,
  2922.         (int) (150),
  2923.         (XtTimerCallbackProc) BlinkSquareProc, NULL);
  2924.    }
  2925. }
  2926.  
  2927.  
  2928. void
  2929. BlinkSquare (row, col, piece)
  2930.     int row, col;
  2931.     ChessSquare piece;
  2932. {
  2933.    BlinkCount = 2*BLINK_COUNT + 1;
  2934.    BlinkRow = row;
  2935.    BlinkCol = col;
  2936.    BlinkPiece = piece;
  2937.    BlinkSquareProc();
  2938. }
  2939.  
  2940.  
  2941. #endif /* BLINK_COUNT */
  2942.  
  2943.  
  2944.  
  2945. void
  2946. ReadGameFile()
  2947. {
  2948.     for (;;) {
  2949.         if (!ReadGameFileProc())
  2950.             return;
  2951.         if (matchMode == MatchOpening)
  2952.             continue;
  2953.         readGameXID = XtAppAddTimeOut(appContext,
  2954.             (int) (1000 * appData.timeDelay),
  2955.             (XtTimerCallbackProc) ReadGameFile, NULL);
  2956.         break;
  2957.     }
  2958. }
  2959.  
  2960. int
  2961. ReadGameFileProc()
  2962. {
  2963.     int from_x, from_y, to_x, to_y, done;
  2964.     ChessMove move_type;
  2965.     char move[MSG_SIZ];
  2966.  
  2967.     if (gameFileFP == NULL)
  2968.         return (int) False;
  2969.  
  2970.     if (gameMode == PauseGame) return True;
  2971.  
  2972.     if (gameMode != PlayFromGameFile) {
  2973.         fclose(gameFileFP);
  2974.         gameFileFP = NULL;
  2975.         return (int) False;
  2976.     }
  2977.  
  2978.     if (commentUp) {
  2979.         XtPopdown(commentShell);
  2980.         XtDestroyWidget(commentShell);
  2981.         commentUp = False;
  2982.     }       
  2983.  
  2984.     parseGameFile ();
  2985.  
  2986.     move_type = (ChessMove) 0;
  2987.  
  2988.     lastGameMode = gameMode;
  2989.     gameMode = ForceMoves;
  2990.     ModeHighlight();
  2991.     DisplayMessage("End of game file");
  2992.  
  2993.     if (readGameXID != 0) {
  2994.         XtRemoveTimeOut(readGameXID);
  2995.         readGameXID = 0;
  2996.     }
  2997.     fclose(gameFileFP);
  2998.     gameFileFP = NULL;
  2999.  
  3000.     return ((int) False);
  3001. }
  3002.  
  3003. /*
  3004.  * MakeMove() displays moves.  If they are illegal, GNU shogi will detect
  3005.  * this and send an Illegal move message.  XShogi will then retract the move.
  3006.  * The clockMode False case is tricky because it displays the player on move.
  3007.  */
  3008. void
  3009. MakeMove(move_type, from_x, from_y, to_x, to_y)
  3010.     ChessMove *move_type;
  3011.     int from_x, from_y, to_x, to_y;
  3012. {
  3013.     char message[MSG_SIZ], movestr[MSG_SIZ];
  3014.     char pieceChar = '\000';
  3015.         ChessSquare piece;
  3016.  
  3017.     CopyBoard(boards[currentMove + 1], boards[currentMove]);
  3018.     CopyCatches(catches[currentMove + 1], catches[currentMove]);
  3019.  
  3020.     forwardMostMove = ++currentMove;
  3021.  
  3022.     if ((gameMode == PlayFromGameFile) || (gameMode == ForceMoves) ||
  3023.         (gameMode == SetupPosition))
  3024.       DisplayClocks(ReDisplayTimers);
  3025.     else
  3026.       DisplayClocks(SwitchTimers);
  3027.     if ( from_x > 80 ) {
  3028.                 int i = from_x - 81, c = (BLACK_ON_MOVE ? 1 : 0);
  3029.                 ChessSquare cpiece = catchedIndexToPiece[c][i];
  3030.         boards[currentMove][to_y][to_x] = cpiece;
  3031.         DrawSquare(to_y, to_x, cpiece);
  3032.         catches[currentMove][c][i]--;
  3033.         UpdateCatched(c, i, False, False, currentMove);
  3034.     } else if (PromotionPossible(from_y,to_y,piece = boards[currentMove][from_y][from_x])) {
  3035.          ChessSquare cpiece = boards[currentMove][to_y][to_x];
  3036.         if ( cpiece != EmptySquare ) {
  3037.           int i = pieceToCatchedIndex[cpiece];
  3038.           int c = (cpiece < WhitePawn );
  3039.           catches[currentMove][c][i]++;
  3040.           UpdateCatched(c, i, True, False, currentMove);
  3041.         }; 
  3042.         if ( *move_type == NormalMove ) {
  3043.             boards[currentMove][to_y][to_x] = piece;
  3044.         } else {
  3045.             boards[currentMove][to_y][to_x] = piece = pieceToPromoted[piece];
  3046.           pieceChar = '+';
  3047.         }
  3048.         boards[currentMove][from_y][from_x] = EmptySquare;
  3049.         DrawSquare(from_y, from_x, boards[currentMove][from_y][from_x]);
  3050.         DrawSquare(to_y, to_x, boards[currentMove][to_y][to_x]);
  3051.         } else { 
  3052.          ChessSquare piece = boards[currentMove][to_y][to_x];
  3053.         if ( piece != EmptySquare ) {
  3054.           int i = pieceToCatchedIndex[piece];
  3055.           int c = (piece < WhitePawn );
  3056.           catches[currentMove][c][i]++;
  3057.           UpdateCatched(c, i, True, False, currentMove);
  3058.         };
  3059.         *move_type = NormalMove;
  3060.         boards[currentMove][to_y][to_x] =
  3061.           boards[currentMove][from_y][from_x];
  3062.         boards[currentMove][from_y][from_x] = EmptySquare;
  3063.         DrawSquare(to_y, to_x, boards[currentMove][to_y][to_x]);
  3064.         DrawSquare(from_y, from_x,
  3065.                boards[currentMove][from_y][from_x]);
  3066.     }
  3067.  
  3068.     
  3069.     if (gameMode == PlayFromGameFile) {
  3070.         sprintf(message, "%d. %s%s", (currentMove + 1) / 2,
  3071.             BLACK_ON_MOVE ? "... " : "", currentMoveString);
  3072.         strcpy(parseList[currentMove - 1], currentMoveString);
  3073.     } else {
  3074.         MakeAlg(from_x, from_y, to_x, to_y, pieceChar,
  3075.             currentMove - 1, movestr);
  3076.         sprintf(message, "%d. %s%s", (currentMove + 1) / 2,
  3077.             BLACK_ON_MOVE ? "... " : "", movestr);
  3078.         strcpy(parseList[currentMove - 1], movestr);
  3079.     }
  3080.  
  3081.     DisplayMessage(message);
  3082.     XSync(xDisplay, False);
  3083. }
  3084.  
  3085. void
  3086. InitChessProgram(host_name, program_name, pid, to, from, xid)
  3087.     char *host_name, *program_name;
  3088.     int *pid;
  3089.     FILE **to, **from;
  3090.     XtIntervalId *xid;
  3091. {
  3092.     char arg_buf[10];
  3093.     char *arg1, *arg2;
  3094.     int to_prog[2], from_prog[2];
  3095.     FILE *from_fp, *to_fp;
  3096.     int dummy_source;
  3097.     XtInputId dummy_id;
  3098. #if     SYSTEM_FIVE || SYSV
  3099.     char *pty_name;
  3100. #endif
  3101.  
  3102.     if (appData.noChessProgram) return;
  3103.  
  3104. #if    SYSTEM_FIVE || SYSV
  3105.     if ((pty_name = PseudoTTY(&to_prog[1])) == NULL) {
  3106.         fprintf(stderr, "%s: can't open pseudo-tty\n", programName);
  3107.         perror("");
  3108.         exit(1);
  3109.     }
  3110.  
  3111.     from_prog[0] = to_prog[1];
  3112.     to_prog[0] = from_prog[1] = open(pty_name, O_RDWR, 0);
  3113. #if    SVR4
  3114.     if (ioctl (to_prog[0], I_PUSH, "ptem") == -1 ||
  3115.         ioctl (to_prog[0], I_PUSH, "ldterm") == -1 ||
  3116.         ioctl (to_prog[0], I_PUSH, "ttcompat") == -1) {
  3117.         fprintf(stderr, "%s: can't ioctl pseudo-tty\n", programName);
  3118.         perror("");
  3119.         exit(1);
  3120.     }
  3121. #endif
  3122. #else
  3123.     signal(SIGPIPE, CatchPipeSignal);
  3124.     pipe(to_prog);
  3125.     pipe(from_prog);
  3126. #endif
  3127.  
  3128.     if ((*pid = fork()) == 0) {
  3129. #if    !SYSTEM_FIVE && !SYSV
  3130.         signal(SIGPIPE, CatchPipeSignal);
  3131. #endif
  3132.         dup2(to_prog[0], 0);
  3133.         dup2(from_prog[1], 1);
  3134.         close(to_prog[0]);
  3135.         close(to_prog[1]);
  3136.         close(from_prog[0]);
  3137.         close(from_prog[1]);
  3138.         dup2(1, fileno(stderr));    /* force stderr to the pipe */
  3139.         if (appData.searchTime != NULL) {
  3140.             sprintf(arg_buf, "%d", searchTime);
  3141.             arg1 = arg_buf;
  3142.             arg2 = (char *) NULL;
  3143.         } else if (appData.searchDepth > 0) {
  3144.             sprintf(arg_buf, "%d", appData.searchDepth);
  3145.             arg1 = "1";
  3146.             arg2 = "9999";
  3147.         } else {
  3148.             sprintf(arg_buf, "%d", appData.movesPerSession);
  3149.             arg1 = arg_buf;
  3150.             arg2 = appData.timeControl;
  3151.         }
  3152.         if (strcmp(host_name, "localhost") == 0) {
  3153.             execlp(program_name, program_name, arg1, arg2,
  3154.                 (char *) NULL);
  3155.         } else {
  3156.             execlp(appData.remoteShell, appData.remoteShell,
  3157.                 host_name, program_name, arg1, arg2,
  3158.                 (char *) NULL);
  3159.         }
  3160.  
  3161.         perror(program_name);
  3162.         exit(1);
  3163.     }
  3164.  
  3165.     close(to_prog[0]);
  3166.     close(from_prog[1]);
  3167.  
  3168.     *from = from_fp = fdopen(from_prog[0], "r");
  3169.     *to = to_fp = fdopen(to_prog[1], "w");
  3170.     setbuf(from_fp, NULL); setbuf(to_fp, NULL);
  3171.  
  3172.     ReceiveFromProgram(from_fp, &dummy_source, &dummy_id); /*"Chess"*/
  3173.     if (*pid == 0) return;
  3174.  
  3175.     *xid = XtAppAddInput(appContext, fileno(from_fp), 
  3176.                  (XtPointer)XtInputReadMask,
  3177.                  (XtInputCallbackProc)ReceiveFromProgram, 
  3178.                  (XtPointer)from_fp);
  3179.  
  3180.     SendToProgram(appData.initString, *to);
  3181.     SendSearchDepth(*to);
  3182. }
  3183.  
  3184. void
  3185. ShutdownChessPrograms(why)
  3186.     char *why;
  3187. {
  3188.     lastGameMode = gameMode;
  3189.     gameMode = EndOfGame;
  3190.     ModeHighlight();
  3191.     CopyBoard(boards[currentMove + 1], boards[currentMove]);
  3192.     CopyCatches(catches[currentMove + 1], catches[currentMove]);
  3193.     strncpy(parseList[currentMove], why, MOVE_LEN);
  3194.     parseList[currentMove][MOVE_LEN-1] = '\000';
  3195.     currentMove++;
  3196.     DisplayMessage(why);
  3197.  
  3198.     if (readGameXID != 0)
  3199.         XtRemoveTimeOut(readGameXID);
  3200.     readGameXID = 0;
  3201.  
  3202.     if (firstProgramPID != 0) {
  3203.         fclose(fromFirstProgFP);
  3204.         fclose(toFirstProgFP);
  3205.         fromFirstProgFP = toFirstProgFP = NULL;
  3206.         if (kill(firstProgramPID, SIGTERM)==0) 
  3207.           wait((union wait *)0);
  3208.  
  3209.     }
  3210.     firstProgramPID = 0;
  3211.  
  3212.     if (firstProgramXID != 0)
  3213.         XtRemoveInput(firstProgramXID);
  3214.     firstProgramXID = 0;
  3215.  
  3216.     if (secondProgramPID != 0) {
  3217.         fclose(fromSecondProgFP);
  3218.         fclose(toSecondProgFP);
  3219.         fromSecondProgFP = toSecondProgFP = NULL;
  3220.         if (kill(secondProgramPID, SIGTERM)==0) 
  3221.           wait((union wait *)0);
  3222.     }
  3223.     secondProgramPID = 0;
  3224.  
  3225.     if (secondProgramXID != 0)
  3226.         XtRemoveInput(secondProgramXID);
  3227.     secondProgramXID = 0;
  3228.  
  3229.     DisplayClocks(StopTimers);
  3230.  
  3231.      if(matchMode != MatchFalse) {
  3232.          if (appData.saveGameFile[0] != '\0') 
  3233.           SaveGameProc(appData.saveGameFile);
  3234.         exit(0);
  3235.      }
  3236. }
  3237.  
  3238. void
  3239. CommentPopUp(label)
  3240.     char *label;
  3241. {
  3242.     Arg args[2];
  3243.     Position x, y;
  3244.     Dimension bw_width, pw_width;
  3245.  
  3246.     if (commentUp) {
  3247.         XtPopdown(commentShell);
  3248.         XtDestroyWidget(commentShell);
  3249.         commentUp = False;
  3250.     }
  3251.  
  3252.     DisplayMessage("Comment");
  3253.  
  3254.     XtSetArg(args[0], XtNwidth, &bw_width);
  3255.     XtGetValues(formWidget, args, 1);
  3256.  
  3257.     XtSetArg(args[0], XtNresizable, True);
  3258.     XtSetArg(args[1], XtNwidth, bw_width - 8);
  3259.  
  3260.     commentShell = XtCreatePopupShell("Comment",
  3261.         transientShellWidgetClass, commandsWidget, args, 2);
  3262.  
  3263.     XtSetArg(args[0], XtNlabel, label);
  3264.  
  3265.     (void) XtCreateManagedWidget("commentLabel", labelWidgetClass,
  3266.         commentShell, args, 1);
  3267.  
  3268.     XtRealizeWidget(commentShell);
  3269.  
  3270.     XtSetArg(args[0], XtNwidth, &pw_width);
  3271.     XtGetValues(commentShell, args, 1);
  3272.  
  3273.     XtTranslateCoords(shellWidget, (bw_width - pw_width) / 2, -50, &x, &y);
  3274.  
  3275.     XtSetArg(args[0], XtNx, x);
  3276.     XtSetArg(args[1], XtNy, y);
  3277.     XtSetValues(commentShell, args, 2);
  3278.  
  3279.     XtPopup(commentShell, XtGrabNone);
  3280.     commentUp = True;
  3281. }
  3282.  
  3283. void
  3284. FileNamePopUp(label, proc)
  3285.     char *label;
  3286.     void (*proc) P((char *name));
  3287. {
  3288.     Arg args[2];
  3289.     Widget popup, dialog;
  3290.     Position x, y;
  3291.     Dimension bw_width, pw_width;
  3292.  
  3293.     fileProc = proc;
  3294.  
  3295.     XtSetArg(args[0], XtNwidth, &bw_width);
  3296.     XtGetValues(boardWidget, args, 1);
  3297.  
  3298.     XtSetArg(args[0], XtNresizable, True);
  3299.     XtSetArg(args[1], XtNwidth, DIALOG_SIZE);
  3300.  
  3301.     popup = XtCreatePopupShell("File Name Prompt",
  3302.         transientShellWidgetClass, commandsWidget, args, 2);
  3303.  
  3304.     XtSetArg(args[0], XtNlabel, label);
  3305.     XtSetArg(args[1], XtNvalue, "");
  3306.  
  3307.     dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
  3308.         popup, args, 2);
  3309.  
  3310.     XawDialogAddButton(dialog, "ok", FileNameCallback, (XtPointer) dialog);
  3311.     XawDialogAddButton(dialog, "cancel", FileNameCallback,
  3312.                (XtPointer) dialog);
  3313.  
  3314.     XtRealizeWidget(popup);
  3315.  
  3316.     XtSetArg(args[0], XtNwidth, &pw_width);
  3317.     XtGetValues(popup, args, 1);
  3318.  
  3319.     XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2, 10, &x, &y);
  3320.  
  3321.     XtSetArg(args[0], XtNx, x);
  3322.     XtSetArg(args[1], XtNy, y);
  3323.     XtSetValues(popup, args, 2);
  3324.  
  3325.     XtPopup(popup, XtGrabExclusive);
  3326.     filenameUp = True;
  3327.  
  3328.     XtSetKeyboardFocus(shellWidget, popup);
  3329. }
  3330.  
  3331. void
  3332. FileNameCallback(w, client_data, call_data)
  3333.     Widget w;
  3334.     XtPointer client_data, call_data;
  3335. {
  3336.     String name;
  3337.     Arg args[1];
  3338.  
  3339.     XtSetArg(args[0], XtNlabel, &name);
  3340.     XtGetValues(w, args, 1);
  3341.  
  3342.     if (strcmp(name, "cancel") == 0) {
  3343.         XtPopdown(w = XtParent(XtParent(w)));
  3344.         XtDestroyWidget(w);
  3345.         filenameUp = False;
  3346.         ModeHighlight();
  3347.         return;
  3348.     }
  3349.  
  3350.     FileNameAction(w, NULL);
  3351. }
  3352.  
  3353. void
  3354. FileNameAction(w, event)
  3355.     Widget w;
  3356.     XEvent *event;
  3357. {
  3358.     char buf[MSG_SIZ];
  3359.     String name;
  3360.  
  3361.     name = XawDialogGetValueString(w = XtParent(w));
  3362.  
  3363.     if ((name != NULL) && (*name != '\0')) {
  3364.         strcpy(buf, name);
  3365.         XtPopdown(w = XtParent(w));
  3366.         XtDestroyWidget(w);
  3367.         filenameUp = False;
  3368.         (*fileProc)(buf);  /* I can't see a way not
  3369.                       to use a global here */
  3370.         ModeHighlight();
  3371.         return;
  3372.     }
  3373.  
  3374.     XtPopdown(w = XtParent(w));
  3375.     XtDestroyWidget(w);
  3376.     filenameUp = False;
  3377.     ModeHighlight();
  3378. }
  3379.  
  3380.  
  3381.  
  3382.  
  3383. typedef struct {
  3384.     ChessSquare piece;
  3385.     int to_x, to_y;
  3386. } PromotionMoveInfo;
  3387.  
  3388. static PromotionMoveInfo pmi;  /*making this global is gross */
  3389.       
  3390.  
  3391. void
  3392. PromotionPopUp(piece, to_x, to_y)
  3393.          ChessSquare piece;
  3394.          int to_x, to_y;
  3395. {
  3396.     Arg args[2];
  3397.     Widget dialog;
  3398.     Position x, y;
  3399.     Dimension bw_width, bw_height, pw_width, pw_height;
  3400.  
  3401.     pmi.piece = piece;
  3402.     pmi.to_x = to_x;
  3403.     pmi.to_y = to_y;
  3404.  
  3405.     XtSetArg(args[0], XtNwidth, &bw_width);
  3406.     XtSetArg(args[1], XtNheight, &bw_height);
  3407.     XtGetValues(boardWidget, args, 2);
  3408.  
  3409.     XtSetArg(args[0], XtNresizable, True);
  3410.     promotionShell = XtCreatePopupShell("Promotion",
  3411.         transientShellWidgetClass, commandsWidget, args, 1);
  3412.                                       
  3413.     XtSetArg(args[0], XtNlabel, "Promote piece?");
  3414.     dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
  3415.         promotionShell, args, 1);
  3416.  
  3417.     XawDialogAddButton(dialog, "Yes", PromotionCallback, 
  3418.                (XtPointer) dialog);
  3419.     XawDialogAddButton(dialog, "No", PromotionCallback, 
  3420.                (XtPointer) dialog);
  3421.     XawDialogAddButton(dialog, "cancel", PromotionCallback, 
  3422.                (XtPointer) dialog);
  3423.  
  3424.     XtRealizeWidget(promotionShell);
  3425.  
  3426.     XtSetArg(args[0], XtNwidth, &pw_width);
  3427.     XtSetArg(args[1], XtNheight, &pw_height);
  3428.     XtGetValues(promotionShell, args, 2);
  3429.  
  3430.     XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
  3431.               LINE_GAP + squareSize/3 +
  3432.               ((piece == BlackPawn) ^ (flipView) ?
  3433.                0 : 6*(squareSize + LINE_GAP)),
  3434.               &x, &y);
  3435.  
  3436.     XtSetArg(args[0], XtNx, x);
  3437.     XtSetArg(args[1], XtNy, y);
  3438.     XtSetValues(promotionShell, args, 2);
  3439.  
  3440.     XtPopup(promotionShell, XtGrabNone);
  3441.  
  3442.     promotionUp = True;
  3443. }
  3444.  
  3445. void
  3446. PromotionCallback(w, client_data, call_data)
  3447.     Widget w;
  3448.     XtPointer client_data, call_data;
  3449. {
  3450.     String name;
  3451.     Arg args[1];
  3452.     ChessMove move_type;
  3453.  
  3454.     XtSetArg(args[0], XtNlabel, &name);
  3455.     XtGetValues(w, args, 1);
  3456.  
  3457.     XtPopdown(w = XtParent(XtParent(w)));
  3458.     XtDestroyWidget(w);
  3459.     promotionUp = False;
  3460.  
  3461.     if (fromX == -1) return;
  3462.  
  3463.     if (strcmp(name, "Yes") == 0) {
  3464.         if ((int) pmi.piece < (int) WhitePawn)
  3465.           move_type = BlackPromotion;
  3466.         else
  3467.           move_type = WhitePromotion;
  3468.     } else if (strcmp(name, "No") == 0) {
  3469.                 move_type = NormalMove;
  3470.     } else /* strcmp(name, "cancel") == 0 */ {
  3471.         fromX = fromY = -1;
  3472.         return;
  3473.     }
  3474.  
  3475.     MakeMove(&move_type, fromX, fromY, pmi.to_x, pmi.to_y);
  3476.     FinishUserMove(move_type, pmi.to_x, pmi.to_y);
  3477. }
  3478.  
  3479.  
  3480. typedef struct {
  3481.     char mode[2];
  3482.     char name[100];
  3483. } FileModeInfo;
  3484.  
  3485. static FileModeInfo fmi;
  3486.  
  3487.  
  3488. void
  3489. FileModePopUp (name)
  3490.     char *name;
  3491. {
  3492.     Arg args[2];
  3493.     Widget dialog;
  3494.     Position x, y;
  3495.     Dimension bw_width, bw_height, pw_width, pw_height;
  3496.  
  3497.     strcpy(fmi.name,name);
  3498.  
  3499.     XtSetArg(args[0], XtNwidth, &bw_width);
  3500.     XtSetArg(args[1], XtNheight, &bw_height);
  3501.     XtGetValues(boardWidget, args, 2);
  3502.  
  3503.     XtSetArg(args[0], XtNresizable, True);
  3504.     filemodeShell = XtCreatePopupShell("FileMode",
  3505.         transientShellWidgetClass, commandsWidget, args, 1);
  3506.                                       
  3507.     XtSetArg(args[0], XtNlabel, "Append to existing file?");
  3508.     dialog = XtCreateManagedWidget("filemode", dialogWidgetClass,
  3509.         filemodeShell, args, 1);
  3510.  
  3511.     XawDialogAddButton(dialog, "Yes", FileModeCallback, 
  3512.                (XtPointer) dialog);
  3513.     XawDialogAddButton(dialog, "No", FileModeCallback, 
  3514.                (XtPointer) dialog);
  3515.     XawDialogAddButton(dialog, "cancel", FileModeCallback, 
  3516.                (XtPointer) dialog);
  3517.  
  3518.     XtRealizeWidget(filemodeShell);
  3519.  
  3520.     XtSetArg(args[0], XtNwidth, &pw_width);
  3521.     XtSetArg(args[1], XtNheight, &pw_height);
  3522.     XtGetValues(filemodeShell, args, 2);
  3523.  
  3524.     XtTranslateCoords(boardWidget, (bw_width - pw_width) / 2,
  3525.               LINE_GAP + squareSize/3 +
  3526.               (6*(squareSize + LINE_GAP)),
  3527.               &x, &y);
  3528.  
  3529.     XtSetArg(args[0], XtNx, x);
  3530.     XtSetArg(args[1], XtNy, y);
  3531.     XtSetValues(filemodeShell, args, 2);
  3532.  
  3533.     XtPopup(filemodeShell, XtGrabNone);
  3534.  
  3535.     filemodeUp = True;
  3536. }
  3537.  
  3538. void
  3539. FileModeCallback(w, client_data, call_data)
  3540.     Widget w;
  3541.     XtPointer client_data, call_data;
  3542. {
  3543.     String name;
  3544.     Arg args[1];
  3545.  
  3546.     XtSetArg(args[0], XtNlabel, &name);
  3547.     XtGetValues(w, args, 1);
  3548.  
  3549.     XtPopdown(w = XtParent(XtParent(w)));
  3550.     XtDestroyWidget(w);
  3551.  
  3552.     if (strcmp(name, "Yes") == 0) {
  3553.         strcpy(fmi.mode,"a");
  3554.     } else if (strcmp(name, "No") == 0) {
  3555.                 strcpy(fmi.mode,"w");
  3556.     } else /* strcmp(name, "cancel") == 0 */ {
  3557.                filemodeUp = False;
  3558.            return;
  3559.     }
  3560.  
  3561.     XtPopdown(filemodeShell);
  3562.     XtDestroyWidget(filemodeShell);
  3563.  
  3564.     SaveGameProc(fmi.name);
  3565.  
  3566.     filemodeUp = False;
  3567.  
  3568. }
  3569.  
  3570.  
  3571.  
  3572.  
  3573.  
  3574.  
  3575.  
  3576. void
  3577. SelectCommand(w, client_data, call_data)
  3578.     Widget w;
  3579.     XtPointer client_data, call_data;
  3580. {
  3581.     XawListReturnStruct *list_return = XawListShowCurrent(w);
  3582.  
  3583.     fromX = fromY = -1;
  3584.  
  3585.     if (promotionUp) {
  3586.         XtPopdown(promotionShell);
  3587.         XtDestroyWidget(promotionShell);
  3588.         promotionUp = False;
  3589.     }
  3590.  
  3591.     if ((gameMode == PauseGame)
  3592.         && (list_return->list_index != (int) ButtonPause))
  3593.         PauseProc();
  3594.  
  3595.     switch ((Button) list_return->list_index) {
  3596.           case ButtonQuit:
  3597.         QuitProc();
  3598.         break;
  3599.           case ButtonBackward:
  3600.         BackwardProc();
  3601.         break;
  3602.           case ButtonForward:
  3603.         ForwardProc();
  3604.         break;
  3605.           case ButtonFlipView:
  3606.         FlipProc();
  3607.         break;
  3608.           case ButtonReset:
  3609.         ResetFileProc();
  3610.         ResetProc();
  3611.         break;
  3612.           case ButtonSaveGame:
  3613.         if (appData.saveGameFile[0] == '\0')
  3614.             FileNamePopUp("Filename for saved game?",
  3615.                       SaveGameProc);
  3616.         else
  3617.             SaveGameProc(appData.saveGameFile);
  3618.         break;
  3619.           case ButtonSavePosition:
  3620.         if (appData.savePositionFile[0] == '\0')
  3621.             FileNamePopUp("Filename for saved position?",
  3622.                       SavePositionProc);
  3623.         else
  3624.             SavePositionProc(appData.savePositionFile);
  3625.         break;
  3626.           case ButtonHint:
  3627.         HintProc();
  3628.         break;
  3629. #ifdef notdef
  3630.           case ButtonSwitchSides:
  3631.         SwitchProc();
  3632.         break;
  3633. #endif /*notdef*/
  3634.           case ButtonEditPosition:
  3635.         EditPositionProc();
  3636.         break;        
  3637.           case ButtonLoadPosition:
  3638.         if (gameMode != BeginningOfGame) {
  3639.             DisplayMessage("Press Reset first");
  3640.             break;
  3641.         }
  3642.         if (appData.loadPositionFile == NULL)
  3643.             FileNamePopUp("Position file name?",
  3644.                 VOID_PROC SetupPositionFromFileProc);
  3645.         else
  3646.             (void) SetupPositionFromFileProc(
  3647.               appData.loadPositionFile);
  3648.         break;
  3649.           case ButtonLoadGame:
  3650.         GameProc();
  3651.         break;
  3652.           case ButtonMachineWhite:
  3653.         MachinePlaysWhiteProc();
  3654.         break;
  3655.           case ButtonMachineBlack:
  3656.         MachinePlaysBlackProc();
  3657.         break;
  3658.           case ButtonTwoMachines:
  3659.         TwoMachinesPlayProc();
  3660.         break;
  3661.           case ButtonForceMoves:
  3662.         ForceProc();
  3663.         break;
  3664.           case ButtonPause:
  3665.         PauseProc();
  3666.         break;
  3667.     }
  3668.  
  3669.     if (!filenameUp) ModeHighlight();
  3670. }
  3671.  
  3672. void
  3673. ModeHighlight()
  3674. {
  3675.     switch (gameMode) {
  3676.           case BeginningOfGame:
  3677.         if (appData.noChessProgram)
  3678.           XawListHighlight(commandsWidget, ButtonForceMoves);
  3679.         else
  3680.           XawListHighlight(commandsWidget, ButtonMachineWhite);
  3681.         break;
  3682.           case MachinePlaysWhite:
  3683.         XawListHighlight(commandsWidget, ButtonMachineWhite);
  3684.         break;
  3685.           case MachinePlaysBlack:
  3686.         XawListHighlight(commandsWidget, ButtonMachineBlack);
  3687.         break;
  3688.           case TwoMachinesPlay:
  3689.         XawListHighlight(commandsWidget, ButtonTwoMachines);
  3690.         break;
  3691.           case ForceMoves:
  3692.           case SetupPosition:
  3693.         XawListHighlight(commandsWidget, ButtonForceMoves);
  3694.         break;
  3695.           case PlayFromGameFile:
  3696.         XawListHighlight(commandsWidget, ButtonLoadGame);
  3697.         break;
  3698.           case PauseGame:
  3699.         XawListHighlight(commandsWidget, ButtonPause);
  3700.         break;
  3701.           case EditPosition:
  3702.         XawListHighlight(commandsWidget, ButtonEditPosition);
  3703.         break;
  3704.           case EndOfGame:
  3705.           default:
  3706.         XawListUnhighlight(commandsWidget);
  3707.         break;
  3708.     }
  3709. }
  3710.  
  3711. /*
  3712.  * Button procedures
  3713.  */
  3714. void
  3715. QuitProc()
  3716. {
  3717.     ShutdownChessPrograms("Quitting");
  3718.     exit(0);
  3719. }
  3720.  
  3721. int
  3722. PlayFromGameFileProc(name)
  3723.     char *name;
  3724. {
  3725.     char buf[MSG_SIZ];
  3726.         ChessMove cm;
  3727.  
  3728.     if (gameMode != BeginningOfGame) {
  3729.         DisplayMessage("Press Reset first");
  3730.         return (int) False;
  3731.     }
  3732.  
  3733.     if (appData.loadGameFile != name) {
  3734.         if (appData.loadGameFile)
  3735.             XtFree(appData.loadGameFile);
  3736.         appData.loadGameFile = XtMalloc(strlen(name)+1);
  3737.         strcpy(appData.loadGameFile, name);
  3738.     }
  3739.  
  3740.     if ((gameFileFP = fopen(name, "r")) == NULL) {
  3741.         sprintf(buf, "Can't open %s", name);
  3742.         DisplayMessage(buf);
  3743.         XtFree(appData.loadGameFile);
  3744.         appData.loadGameFile = NULL;
  3745.         return (int) False;
  3746.     }
  3747.  
  3748.     lastGameMode = gameMode = PlayFromGameFile;
  3749.     ModeHighlight();
  3750.     InitPosition();
  3751.     DisplayClocks(StopTimers);
  3752.     if (firstProgramXID == 0)
  3753.       InitChessProgram(appData.firstHost, appData.firstChessProgram,
  3754.                &firstProgramPID, &toFirstProgFP,
  3755.                &fromFirstProgFP, &firstProgramXID);
  3756.     SendToProgram(appData.initString, toFirstProgFP);
  3757.     SendSearchDepth(toFirstProgFP);
  3758.     SendToProgram("force\n", toFirstProgFP);
  3759.  
  3760.     ReadGameFile();
  3761.  
  3762.     return (int) True;
  3763. }
  3764.  
  3765. void
  3766. ResurrectChessProgram()
  3767.      /* Restart the chess program and feed it all the moves made so far.
  3768.     Used when the user wants to back up from end of game, when gnuchess 
  3769.     has already exited.  Assumes gameMode == EndOfGame. */
  3770. {
  3771.     char buf[MSG_SIZ];
  3772.     int i;
  3773.  
  3774.     if (currentMove > 0)
  3775.       currentMove--;  /* delete "Black wins" or the like */
  3776.  
  3777.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  3778.         &firstProgramPID, &toFirstProgFP, &fromFirstProgFP,
  3779.         &firstProgramXID);
  3780.     SendToProgram(appData.initString, toFirstProgFP);
  3781.     SendSearchDepth(toFirstProgFP);
  3782.     SendToProgram("force\n", toFirstProgFP);
  3783.     gameMode = lastGameMode = ForceMoves;
  3784.     ModeHighlight();
  3785.  
  3786.     i = whitePlaysFirst ? 1 : 0;
  3787.  
  3788.     if (startedFromSetupPosition) {
  3789.         SendBoard(toFirstProgFP, boards[i], catches[i]);
  3790.     }
  3791.  
  3792.     for (; i < currentMove; i++) {
  3793.         strcpy(buf, moveList[i]);
  3794.         SendToProgram(buf, toFirstProgFP);
  3795.     }
  3796.  
  3797.     DisplayClocks(ResetTimers);
  3798.       /* ugh, but there's no way to tell gnuchess what the clocks
  3799.          should read, so the best we can do is bow to its notion.
  3800.          !!gnuchess 4.0 adds a feature that will let us fix this. */
  3801. }
  3802.  
  3803. void
  3804. MachinePlaysWhiteProc()
  3805. {
  3806.     if (gameMode == EditPosition) EditPositionDone();
  3807.  
  3808.     if ((gameMode == EndOfGame) || (gameMode == PlayFromGameFile)
  3809.         || (gameMode == TwoMachinesPlay) || appData.noChessProgram
  3810.         || (gameMode == MachinePlaysWhite))
  3811.         return;
  3812.  
  3813.     if (BLACK_ON_MOVE) {
  3814.         DisplayMessage("It is not White's turn");
  3815.         return;
  3816.     }
  3817.  
  3818.     lastGameMode = gameMode = MachinePlaysWhite;
  3819.     ModeHighlight();
  3820.     SendToProgram(appData.whiteString, toFirstProgFP);
  3821.     DisplayClocks(StartTimers);
  3822. }
  3823.  
  3824. void
  3825. ForwardProc()
  3826. {
  3827.     char buf[MSG_SIZ];
  3828.     int i, j;
  3829.  
  3830.     if (gameMode == BeginningOfGame) {
  3831.         if (currentMove != 0)
  3832.             return;
  3833.         if (appData.loadGameFile != NULL) {
  3834.             if (PlayFromGameFileProc(appData.loadGameFile)) {
  3835.                 XtRemoveTimeOut(readGameXID);
  3836.                 readGameXID = 0;
  3837.             }
  3838.         }
  3839.         return;
  3840.     }
  3841.  
  3842.     if ((gameMode == EndOfGame) || (gameMode == TwoMachinesPlay)
  3843.         || (gameMode == EditPosition)
  3844.         || ((currentMove == 0) && (forwardMostMove == 0)))
  3845.         return;
  3846.  
  3847.     if ((gameMode != PlayFromGameFile) && (currentMove >= forwardMostMove))
  3848.         return;
  3849.  
  3850.     if (gameMode != PauseGame) {
  3851.         PauseProc();
  3852.         if (readGameXID != 0) {
  3853.             XtRemoveTimeOut(readGameXID);
  3854.             readGameXID = 0;
  3855.         }
  3856.     }
  3857.  
  3858.     if (currentMove >= forwardMostMove) {
  3859.         ReadGameFileProc();
  3860.         return;
  3861.     }
  3862.  
  3863.     if ((gameMode != ForceMoves) && (gameMode != PlayFromGameFile) &&
  3864.         (gameMode != SetupPosition)) {
  3865.         lastGameMode = gameMode = ForceMoves;
  3866.         ModeHighlight();
  3867.         SendToProgram("force\n", toFirstProgFP);
  3868.         DisplayClocks(StopTimers);
  3869.     }
  3870.  
  3871.     for (i = 0; i < BOARD_SIZE; i++)
  3872.       for (j = 0; j < BOARD_SIZE; j++)
  3873.         if (boards[currentMove + 1][i][j] != boards[currentMove][i][j])
  3874.           DrawSquare(i, j, boards[currentMove + 1][i][j]);
  3875.  
  3876.         UpdateCatched(0,0,False,True,currentMove+1);
  3877.         UpdateCatched(1,0,False,True,currentMove+1);
  3878.  
  3879.     sprintf(buf, "%d. %s%s", (currentMove / 2) + 1,
  3880.         BLACK_ON_MOVE ? "... " : "", parseList[currentMove]);
  3881.     DisplayMessage(buf);
  3882.     strcpy(buf, moveList[currentMove++]);
  3883.     SendToProgram(buf, toFirstProgFP);
  3884.     DisplayClocks(ReDisplayTimers);
  3885. }
  3886.  
  3887. void
  3888. ResetFileProc()
  3889. {
  3890.     char *buf = "";
  3891.  
  3892.     if (appData.loadGameFile);
  3893.         XtFree(appData.loadGameFile);
  3894.     if (appData.loadPositionFile);
  3895.         XtFree(appData.loadPositionFile);
  3896.     appData.loadGameFile = appData.loadPositionFile = NULL;
  3897.     DisplayName(buf);
  3898.     if (gameFileFP != NULL) {
  3899.         fclose(gameFileFP);
  3900.         gameFileFP = NULL;
  3901.     }
  3902. }
  3903.  
  3904. void
  3905. ResetProc()
  3906. {
  3907.     flipView = False;
  3908.     startedFromSetupPosition = whitePlaysFirst = False;
  3909.     matchMode = MatchFalse;
  3910.     firstMove = True;
  3911.     blackFlag = whiteFlag = False;
  3912.     maybeThinking = False;
  3913.  
  3914.     ShutdownChessPrograms("");
  3915.     lastGameMode = gameMode = BeginningOfGame;
  3916.     ModeHighlight();
  3917.     InitPosition();
  3918.     InitChessProgram(appData.firstHost, appData.firstChessProgram,
  3919.              &firstProgramPID, &toFirstProgFP,
  3920.              &fromFirstProgFP, &firstProgramXID);
  3921.     DisplayClocks(ResetTimers);
  3922.     if (commentUp) {
  3923.         XtPopdown(commentShell);
  3924.         XtDestroyWidget(commentShell);
  3925.         commentUp = False;
  3926.     }
  3927.     if (promotionUp) {
  3928.         XtPopdown(promotionShell);
  3929.         XtDestroyWidget(promotionShell);
  3930.         promotionUp = False;
  3931.     }
  3932. }
  3933.  
  3934.  
  3935.  
  3936.  
  3937. static
  3938. void
  3939. ClearCatches (catches)
  3940.     Catched catches;
  3941. {
  3942.     int c, p;
  3943.     for ( c = 0; c <= 1; c++)
  3944.         for ( p = 0; p <= 7; p++ )
  3945.             catches[c][p] = 0;
  3946. }
  3947.  
  3948.  
  3949.  
  3950.  
  3951.  
  3952. int
  3953. SetupPositionFromFileProc(name)
  3954.     char *name;
  3955. {
  3956.     char *p, line[MSG_SIZ], buf[MSG_SIZ];
  3957.     Board initial_position;
  3958.     Catched initial_catches;
  3959.     FILE *fp;
  3960.     int i, j;
  3961.  
  3962.     if (gameMode != BeginningOfGame) {
  3963.         DisplayMessage("Press Reset first");
  3964.         return (int) False;
  3965.     }
  3966.  
  3967.     if (appData.loadPositionFile != name) {
  3968.         if (appData.loadPositionFile)
  3969.             XtFree(appData.loadPositionFile);
  3970.         appData.loadPositionFile = XtMalloc(strlen(name)+1);
  3971.         strcpy(appData.loadPositionFile, name);
  3972.     }
  3973.  
  3974.     if ((fp = fopen(name, "r")) == NULL) {
  3975.         sprintf(buf, "Can't open %s", name);
  3976.         DisplayMessage(buf);
  3977.         XtFree(appData.loadPositionFile);
  3978.         appData.loadPositionFile = NULL;
  3979.         return (int) False;
  3980.     }
  3981.  
  3982.     lastGameMode = gameMode = SetupPosition;
  3983.     ModeHighlight();
  3984.     startedFromSetupPosition = True;
  3985.  
  3986.     if (firstProgramXID == 0)
  3987.       InitChessProgram(appData.firstHost, appData.firstChessProgram,
  3988.                &firstProgramPID, &toFirstProgFP,
  3989.                &fromFirstProgFP, &firstProgramXID);
  3990.  
  3991.     /*
  3992.      * skip header information in position file
  3993.      */
  3994.     fgets(line, MSG_SIZ, fp);
  3995.     line[strlen(line) - 1] = '\0';
  3996.     DisplayName(line);
  3997.     fgets(line, MSG_SIZ, fp);
  3998.     fgets(line, MSG_SIZ, fp);
  3999.  
  4000.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  4001.         fgets(line, MSG_SIZ, fp);
  4002.         for (p = line, j = 0; j < BOARD_SIZE; p++) {
  4003.           int promoted;
  4004.             if (*p == '+')
  4005.               {
  4006.                 promoted = True;
  4007.               }              
  4008.             if (*p == ' ')
  4009.               {
  4010.                 promoted = False;
  4011.               }
  4012.             p++;              
  4013.             initial_position[i][j++] = CharToPiece(*p,promoted);
  4014.         }
  4015.     }
  4016.         { int color;
  4017.       for ( color = 0; color <= 1; color++ ) {
  4018.         fscanf(fp, "%i%i%i%i%i%i%i%i\n",
  4019.         &initial_catches[color][pawn],
  4020.         &initial_catches[color][lance],
  4021.         &initial_catches[color][knight],
  4022.         &initial_catches[color][silver],
  4023.         &initial_catches[color][gold],
  4024.         &initial_catches[color][bishop],
  4025.         &initial_catches[color][rook],
  4026.         &initial_catches[color][king]);
  4027.       };
  4028.     }
  4029.  
  4030.     whitePlaysFirst = False;
  4031.         if (!feof(fp)) {
  4032.         fgets(line, MSG_SIZ, fp);
  4033.         if (strncmp(line, "white", strlen("white"))==0)
  4034.           whitePlaysFirst = True;
  4035.     }
  4036.     fclose(fp);
  4037.  
  4038.     if (whitePlaysFirst) {
  4039.         CopyBoard(boards[0], initial_position);
  4040.                 CopyCatches(catches[0], initial_catches);
  4041.         strcpy(moveList[0], " ...\n");
  4042.         strcpy(parseList[0], " ...\n");
  4043.         currentMove = forwardMostMove = 1;
  4044.         CopyBoard(boards[1], initial_position);
  4045.                 CopyCatches(catches[1], initial_catches);
  4046.         SendToProgram("force\n", toFirstProgFP);
  4047.         SendCurrentBoard(toFirstProgFP);
  4048.         DisplayMessage("White to play");
  4049.     } else {
  4050.         currentMove = forwardMostMove = 0;
  4051.         CopyBoard(boards[0], initial_position);
  4052.                 CopyCatches(catches[0], initial_catches);
  4053.         SendCurrentBoard(toFirstProgFP);
  4054.         SendToProgram("force\n", toFirstProgFP);
  4055.         DisplayMessage("Black to play");
  4056.     }
  4057.  
  4058.     DisplayClocks(ResetTimers);
  4059.     DrawPosition(boardWidget, (XExposeEvent *) NULL);
  4060.  
  4061.     return (int) True;
  4062. }
  4063.  
  4064. void
  4065. EditPositionProc()
  4066. {
  4067.     if (gameMode == EditPosition) return;
  4068.  
  4069.     ForceProc();
  4070.     if (gameMode != ForceMoves) return;
  4071.  
  4072.     DisplayName("<-- Press to set side to play next");
  4073.     DisplayMessage("Mouse: 1=drag, 2=black, 3=white");
  4074.  
  4075.     lastGameMode = gameMode = EditPosition;
  4076.     ModeHighlight();
  4077.     if (currentMove > 0)
  4078.       CopyBoard(boards[0], boards[currentMove]);
  4079.     
  4080.     whitePlaysFirst = !BLACK_ON_MOVE;
  4081.     currentMove = forwardMostMove = 0;
  4082. }
  4083.  
  4084. void
  4085. EditPositionDone()
  4086. {
  4087.     startedFromSetupPosition = True;
  4088.     SendToProgram(appData.initString, toFirstProgFP);
  4089.     SendSearchDepth(toFirstProgFP);
  4090.     if (whitePlaysFirst) {
  4091.         strcpy(moveList[0], " ...\n");
  4092.         strcpy(parseList[0], " ...\n");
  4093.         currentMove = forwardMostMove = 1;
  4094.         CopyBoard(boards[1], boards[0]);
  4095.         CopyCatches(catches[1], catches[0]);
  4096.         SendToProgram("force\n", toFirstProgFP);
  4097.         SendCurrentBoard(toFirstProgFP);
  4098.         DisplayName(" ");
  4099.         DisplayMessage("White to play");
  4100.     } else {
  4101.         currentMove = forwardMostMove = 0;
  4102.         SendCurrentBoard(toFirstProgFP);
  4103.         SendToProgram("force\n", toFirstProgFP);
  4104.         DisplayName(" ");
  4105.         DisplayMessage("Black to play");
  4106.     }
  4107.     lastGameMode = gameMode = SetupPosition;
  4108. }
  4109.  
  4110. void
  4111. MachinePlaysBlackProc()
  4112. {
  4113.     if (gameMode == EditPosition) EditPositionDone();
  4114.  
  4115.     if ((gameMode == EndOfGame) || (gameMode == PlayFromGameFile)
  4116.         || (gameMode == TwoMachinesPlay) || appData.noChessProgram
  4117.         || (gameMode == MachinePlaysBlack))
  4118.         return;
  4119.  
  4120.     if (!BLACK_ON_MOVE) {
  4121.         DisplayMessage("It is not Black's turn");
  4122.         return;
  4123.     }
  4124.  
  4125.     lastGameMode = gameMode = MachinePlaysBlack;
  4126.     ModeHighlight();
  4127.     SendToProgram(appData.blackString, toFirstProgFP);
  4128.     DisplayClocks(StartTimers);
  4129. }
  4130.  
  4131. void
  4132. BackwardProc()
  4133. {
  4134.     int i, j;
  4135.     char buf[MSG_SIZ];
  4136.  
  4137.     if ((currentMove <= 0) || (gameMode == TwoMachinesPlay)
  4138.         || (matchMode != MatchFalse) || (gameMode == EditPosition))
  4139.         return;
  4140.  
  4141.     if ((currentMove == 1) && whitePlaysFirst) return;
  4142.  
  4143.     if (gameMode == EndOfGame) ResurrectChessProgram();
  4144.  
  4145.     if ((BLACK_ON_MOVE && gameMode == MachinePlaysBlack)
  4146.         || (!BLACK_ON_MOVE && gameMode == MachinePlaysWhite)) {
  4147.         DisplayMessage("Wait until your turn");
  4148.         return;
  4149.     }
  4150.  
  4151.     Attention(firstProgramPID);
  4152.  
  4153.     SendToProgram("undo\n", toFirstProgFP);
  4154.  
  4155.     currentMove--;
  4156.     if ((gameMode != ForceMoves) && (gameMode != PlayFromGameFile) &&
  4157.         (gameMode != SetupPosition)) {
  4158.         SendToProgram("force\n", toFirstProgFP);
  4159.         lastGameMode = gameMode = ForceMoves;
  4160.         ModeHighlight();
  4161.         DisplayClocks(StopTimers);
  4162.         }
  4163.     DisplayClocks(ReDisplayTimers);
  4164.  
  4165.     if (gameMode != PauseGame && gameMode != ForceMoves) {
  4166.         PauseProc();
  4167.         if (readGameXID != 0) {
  4168.             XtRemoveTimeOut(readGameXID);
  4169.             readGameXID = 0;
  4170.         }
  4171.     }
  4172.  
  4173.     if (currentMove > 0) {
  4174.         sprintf(buf, "%d. %s%s", (currentMove + 1) / 2,
  4175.             BLACK_ON_MOVE ? "... " : "",
  4176.             parseList[currentMove - 1]);
  4177.         DisplayMessage(buf);
  4178.     } else {
  4179.         DisplayMessage("");
  4180.     }
  4181.  
  4182.     for (i = 0; i < BOARD_SIZE; i++)
  4183.         for (j = 0; j < BOARD_SIZE; j++)
  4184.             if (boards[currentMove][i][j] !=
  4185.                 boards[currentMove + 1][i][j]) {
  4186.                 DrawSquare(i, j, boards[currentMove][i][j]);
  4187.             }
  4188.         UpdateCatched(0,0,False,True,currentMove);
  4189.         UpdateCatched(1,0,False,True,currentMove);
  4190. }
  4191.  
  4192. void
  4193. FlipProc()
  4194. {
  4195.     flipView = !flipView;
  4196.     DrawPosition(boardWidget, (XExposeEvent *) NULL);
  4197. }
  4198.  
  4199. void
  4200. SaveGameProc(name)
  4201.     char *name;
  4202. {
  4203.     char buf[MSG_SIZ], black_move[MSG_SIZ], white_move[MSG_SIZ];
  4204.     int i, len, move = 0;
  4205.     time_t tm;
  4206.  
  4207.     if ( !filemodeUp ) {
  4208.       strcpy(fmi.mode,"w");
  4209.       if ((gameFileFP = fopen(name, "r")) != NULL) {
  4210.         fclose(gameFileFP);
  4211.         FileModePopUp(name);
  4212.         return;
  4213.       }
  4214.     }
  4215.  
  4216.     if ((gameFileFP = fopen(name, fmi.mode)) == NULL) {
  4217.         sprintf(buf, "Can't open %s (mode %s)", name, fmi.mode);
  4218.         DisplayMessage(buf);
  4219.         return;
  4220.     }
  4221.  
  4222.     tm = time((time_t *) NULL);
  4223.     gethostname(buf, MSG_SIZ);
  4224.         
  4225. #ifdef FULL_SAVE_GAME 
  4226.     fprintf(gameFileFP, "# %s game file -- %s", programName, ctime(&tm)); 
  4227.     switch (lastGameMode) {
  4228.           case MachinePlaysBlack:
  4229.         fprintf(gameFileFP, "\t%s@%s vs. %s@%s\n",
  4230.             appData.firstChessProgram, appData.firstHost,
  4231.             getpwuid(getuid())->pw_name, buf);
  4232.         break;
  4233.           case MachinePlaysWhite:
  4234.         fprintf(gameFileFP, "\t%s@%s vs. %s@%s\n",
  4235.             getpwuid(getuid())->pw_name, buf,
  4236.             appData.firstChessProgram, appData.firstHost);
  4237.         break;
  4238.           case TwoMachinesPlay:
  4239.         fprintf(gameFileFP, "\t%s@%s vs. %s@%s\n",
  4240.             appData.secondChessProgram, appData.secondHost,
  4241.             appData.firstChessProgram, appData.firstHost);
  4242.         break;
  4243.           default:
  4244.         fprintf(gameFileFP, "\n");
  4245.         break;
  4246.     }
  4247.     fprintf(gameFileFP, "\talgebraic\n");
  4248.  
  4249.     for (i = 0; i < currentMove;) {
  4250.         fprintf(gameFileFP, "%d. %s ", ++move, parseList[i++]);
  4251.         if (i >= currentMove) {
  4252.             fprintf(gameFileFP, "\n");
  4253.             break;
  4254.         }
  4255.         if ((len = strlen(parseList[i])) == 0) {
  4256.             fprintf(gameFileFP, "\n");
  4257.             break;
  4258.         }
  4259.         fprintf(gameFileFP, "%s\n", parseList[i++]);
  4260.     }  
  4261. #else
  4262.     fprintf(gameFileFP, "#"); 
  4263.  
  4264.     for (i = 0; i < currentMove;) {
  4265.         if ( i % 5 == 0 )
  4266.           fprintf(gameFileFP, "\n");
  4267.         fprintf(gameFileFP, "%d. %s ", ++move, parseList[i++]);
  4268.         if (i >= currentMove) {
  4269.             fprintf(gameFileFP, "\n");
  4270.             break;
  4271.         }
  4272.         if ((len = strlen(parseList[i])) == 0) {
  4273.             break;
  4274.         }
  4275.         fprintf(gameFileFP, "%s ", parseList[i++]);
  4276.     }  
  4277.     
  4278.     fprintf(gameFileFP, "\n");
  4279. #endif
  4280.  
  4281.     fclose(gameFileFP);
  4282.     gameFileFP = NULL;
  4283. }
  4284.  
  4285. #ifdef notdef  
  4286. /* unused */
  4287. void
  4288. SwitchProc()
  4289. {
  4290.     if (appData.noChessProgram) return;
  4291.     switch (gameMode) {
  4292.     default:
  4293.         return;
  4294.     case MachinePlaysBlack:
  4295.         if (BLACK_ON_MOVE) {
  4296.             DisplayMessage("Wait until your turn");
  4297.             return;
  4298.         }
  4299.         lastGameMode = gameMode = MachinePlaysWhite;
  4300.         ModeHighlight();
  4301.         break;
  4302.     case BeginningOfGame:
  4303.     case MachinePlaysWhite:
  4304.         if (!BLACK_ON_MOVE) {
  4305.             DisplayMessage("Wait until your turn");
  4306.             return;
  4307.         }
  4308.         if (currentMove == 0) {
  4309.             MachinePlaysBlackProc();
  4310.             return;
  4311.         }
  4312.         lastGameMode = gameMode = MachinePlaysBlack;
  4313.         ModeHighlight();
  4314.         break;
  4315.     }
  4316.  
  4317.     Attention(firstProgramPID);
  4318.     SendToProgram("switch\n", toFirstProgFP);
  4319. }
  4320. #endif /*notdef*/
  4321.  
  4322. void
  4323. ForceProc()
  4324. {
  4325.     switch (gameMode) {
  4326.           case MachinePlaysBlack:
  4327.         if (BLACK_ON_MOVE) {
  4328.             DisplayMessage("Wait until your turn");
  4329.             return;
  4330.         }
  4331.         Attention(firstProgramPID);
  4332.         SendToProgram("force\n", toFirstProgFP);
  4333.         break;
  4334.           case MachinePlaysWhite:
  4335.         if (!BLACK_ON_MOVE) {
  4336.             DisplayMessage("Wait until your turn");
  4337.             return;
  4338.         }
  4339.         Attention(firstProgramPID);
  4340.         SendToProgram("force\n", toFirstProgFP);
  4341.         break;
  4342.           case BeginningOfGame:
  4343.         SendToProgram("force\n", toFirstProgFP);
  4344.         break;
  4345.           case PlayFromGameFile:
  4346.         if (readGameXID != 0) {
  4347.             XtRemoveTimeOut(readGameXID);
  4348.             readGameXID = 0;
  4349.         }
  4350.         if (gameFileFP != NULL) {
  4351.             fclose(gameFileFP);
  4352.             gameFileFP = NULL;
  4353.         }
  4354.         break;
  4355.           case EndOfGame:
  4356.         ResurrectChessProgram();
  4357.         break;
  4358.           case EditPosition:
  4359.         EditPositionDone();
  4360.         break;
  4361.           case SetupPosition:
  4362.         break;
  4363.           default:
  4364.         return;
  4365.     }
  4366.  
  4367.     lastGameMode = gameMode = ForceMoves;
  4368.     ModeHighlight();
  4369.     DisplayClocks(StopTimers);
  4370. }
  4371.  
  4372. void
  4373. HintProc()
  4374. {
  4375.     if (appData.noChessProgram) return;
  4376.     switch (gameMode) {
  4377.     case MachinePlaysBlack:
  4378.         if (BLACK_ON_MOVE) {
  4379.             DisplayMessage("Wait until your turn");
  4380.             return;
  4381.         }
  4382.         break;
  4383.     case BeginningOfGame:
  4384.     case MachinePlaysWhite:
  4385.         if (!BLACK_ON_MOVE) {
  4386.             DisplayMessage("Wait until your turn");
  4387.             return;
  4388.         }
  4389.         break;
  4390.     default:
  4391.         DisplayMessage("No hint available");
  4392.         return;
  4393.     }
  4394.     Attention(firstProgramPID);
  4395.     SendToProgram("hint\n", toFirstProgFP);
  4396. }
  4397.  
  4398. void
  4399. SavePositionProc(name)
  4400.     char *name;
  4401. {
  4402.     char buf[MSG_SIZ], host_name[MSG_SIZ];
  4403.     FILE *fp;
  4404.     time_t tm;
  4405.     int i, j;
  4406.  
  4407.     if ((fp = fopen(name, "w")) == NULL) {
  4408.         sprintf(buf, "Can't open %s", name);
  4409.         DisplayMessage(buf);
  4410.         return;
  4411.     }
  4412.  
  4413.     tm = time((time_t *) NULL);
  4414.     gethostname(host_name, MSG_SIZ);
  4415.  
  4416.     fprintf(fp, "%s position file -- %s", programName, ctime(&tm));
  4417.     switch (lastGameMode) {
  4418.     case MachinePlaysBlack:
  4419.         fprintf(fp, "\t%s@%s vs. %s@%s\n", appData.firstChessProgram,
  4420.             appData.firstHost, getpwuid(getuid())->pw_name,
  4421.             host_name);
  4422.         break;
  4423.     case MachinePlaysWhite:
  4424.         fprintf(fp, "\t%s@%s vs. %s@%s\n", getpwuid(getuid())->pw_name,
  4425.             host_name, appData.firstChessProgram,
  4426.             appData.firstHost);
  4427.         break;
  4428.     case TwoMachinesPlay:
  4429.         fprintf(fp, "\t%s@%s vs. %s@%s\n", appData.secondChessProgram,
  4430.             appData.secondHost, appData.firstChessProgram,
  4431.             appData.firstHost);
  4432.         break;
  4433.     default:
  4434.         fprintf(fp, "\n");
  4435.         break;
  4436.     }
  4437.     fprintf(fp, "\n");
  4438.  
  4439.     for (i = BOARD_SIZE - 1; i >= 0; i--) {
  4440.         for (j = 0; j < BOARD_SIZE; j++) {
  4441.             if ( pieceIsPromoted[(int) boards[currentMove][i][j]] )
  4442.                 fprintf(fp,"%c",'+');
  4443.             else
  4444.                 fprintf(fp,"%c",' ');
  4445.             fprintf(fp, "%c",
  4446.                 pieceToChar[(int) boards[currentMove][i][j]]);
  4447.             if (j == BOARD_SIZE - 1) 
  4448.               fputc('\n', fp);
  4449.         }
  4450.     }
  4451.     { int color;
  4452.       for (color = 0; color <= 1; color++)
  4453.         { 
  4454.          fprintf(fp,"%i %i %i %i %i %i %i %i\n",
  4455.             catches[currentMove][color][pawn],
  4456.             catches[currentMove][color][lance],
  4457.             catches[currentMove][color][knight],
  4458.             catches[currentMove][color][silver],
  4459.             catches[currentMove][color][gold],
  4460.             catches[currentMove][color][bishop],
  4461.             catches[currentMove][color][rook],
  4462.             catches[currentMove][color][king]);
  4463.             };
  4464.         }
  4465.  
  4466.     if ((gameMode == EditPosition) ? !whitePlaysFirst : BLACK_ON_MOVE)
  4467.       fprintf(fp, "black to play\n");
  4468.     else
  4469.       fprintf(fp, "white to play\n");
  4470.  
  4471.     fclose(fp);
  4472. }
  4473.  
  4474. void
  4475. TwoMachinesPlayProc()
  4476. {
  4477.     int i;
  4478.     MatchMode matchKind;
  4479.  
  4480.     if ((gameMode == EndOfGame) || (gameMode == TwoMachinesPlay)
  4481.         || appData.noChessProgram)
  4482.         return;
  4483.  
  4484.     if (matchMode == MatchFalse) {
  4485.         switch (gameMode) {
  4486.               case PauseGame:
  4487.               case PlayFromGameFile:
  4488.             return;
  4489.               case MachinePlaysBlack:
  4490.               case MachinePlaysWhite:
  4491.             ForceProc();
  4492.             if (gameMode != ForceMoves) return;
  4493.             matchKind = MatchOpening;
  4494.             break;
  4495.               case ForceMoves:
  4496.             matchKind = MatchOpening;
  4497.             break;
  4498.               case SetupPosition:
  4499.             matchKind = MatchPosition;
  4500.             break;
  4501.               case EditPosition:
  4502.             EditPositionDone();
  4503.             matchKind = MatchPosition;
  4504.             break;
  4505.               case BeginningOfGame:
  4506.               default:
  4507.             matchKind = MatchInit;
  4508.             break;
  4509.         }
  4510.     } else {
  4511.         matchKind = matchMode;
  4512.     }
  4513.  
  4514.     flipView = False;
  4515.     firstMove = False;
  4516.     DisplayClocks(ResetTimers);
  4517.     DisplayClocks(StartTimers);
  4518.  
  4519.     switch (matchKind) {
  4520.           case MatchOpening:
  4521.         if (firstProgramXID == 0) {
  4522.             if (appData.loadGameFile == NULL) {
  4523.                 DisplayMessage("Select game file first");
  4524.                 return;
  4525.             }
  4526.             InitChessProgram(appData.firstHost,
  4527.                      appData.firstChessProgram,
  4528.                      &firstProgramPID, &toFirstProgFP,
  4529.                      &fromFirstProgFP, &firstProgramXID);
  4530.             if (!PlayFromGameFileProc(appData.loadGameFile)) {
  4531.                 ShutdownChessPrograms("Bad game file");
  4532.                 return;
  4533.             }
  4534.             DrawPosition(boardWidget, (XExposeEvent *) NULL);
  4535.         }
  4536.         InitChessProgram(appData.secondHost,
  4537.                  appData.secondChessProgram,
  4538.                  &secondProgramPID, &toSecondProgFP,
  4539.                  &fromSecondProgFP, &secondProgramXID);
  4540.         if (startedFromSetupPosition) {
  4541.             if (whitePlaysFirst) {
  4542.                 i = 1;
  4543.                 SendToProgram("force\n", toSecondProgFP);
  4544.                 SendBoard(toSecondProgFP, boards[i], catches[i]);
  4545.             } else {
  4546.                 i = 0;
  4547.                 SendBoard(toSecondProgFP, boards[i], catches[i]);
  4548.                 SendToProgram("force\n", toSecondProgFP);
  4549.             }
  4550.         } else {
  4551.             i = 0;
  4552.             SendToProgram("force\n", toSecondProgFP);
  4553.         }
  4554.         for (; i < currentMove; i++)
  4555.             SendToProgram(moveList[i], toSecondProgFP);
  4556.         lastGameMode = gameMode = TwoMachinesPlay;
  4557.         ModeHighlight();
  4558.         firstMove = True;
  4559.         if (BLACK_ON_MOVE)
  4560.           SendToProgram(appData.blackString, toSecondProgFP);
  4561.         else
  4562.           SendToProgram(appData.whiteString, toFirstProgFP);
  4563.         break;
  4564.  
  4565.           case MatchPosition:
  4566.         if (firstProgramXID == 0) {
  4567.             if (appData.loadPositionFile == NULL) {
  4568.                 DisplayMessage("Select position file first");
  4569.                 return;
  4570.             }
  4571.             InitChessProgram(appData.firstHost,
  4572.                      appData.firstChessProgram,
  4573.                      &firstProgramPID, &toFirstProgFP,
  4574.                      &fromFirstProgFP, &firstProgramXID);
  4575.             if (!SetupPositionFromFileProc(
  4576.                         appData.loadPositionFile))
  4577.                 return;
  4578.         }
  4579.         InitChessProgram(appData.secondHost,
  4580.                  appData.secondChessProgram,
  4581.                  &secondProgramPID, &toSecondProgFP,
  4582.                  &fromSecondProgFP, &secondProgramXID);
  4583.         if (whitePlaysFirst)
  4584.           SendToProgram("force\n", toSecondProgFP);
  4585.         SendCurrentBoard(toSecondProgFP);
  4586.         lastGameMode = gameMode = TwoMachinesPlay;
  4587.         ModeHighlight();
  4588.         firstMove = True;
  4589.         if (BLACK_ON_MOVE)
  4590.           SendToProgram(appData.blackString, toSecondProgFP);
  4591.         else
  4592.           SendToProgram(appData.whiteString, toFirstProgFP);
  4593.         break;
  4594.  
  4595.           case MatchInit:
  4596.         InitPosition();
  4597.         if (firstProgramXID == 0)
  4598.             InitChessProgram(appData.firstHost,
  4599.                      appData.firstChessProgram,
  4600.                      &firstProgramPID, &toFirstProgFP,
  4601.                      &fromFirstProgFP, &firstProgramXID);
  4602.         InitChessProgram(appData.secondHost,
  4603.                  appData.secondChessProgram,
  4604.                  &secondProgramPID, &toSecondProgFP,
  4605.                  &fromSecondProgFP, &secondProgramXID);
  4606.         lastGameMode = gameMode = TwoMachinesPlay;
  4607.         ModeHighlight();
  4608.         SendToProgram(appData.blackString, toSecondProgFP);
  4609.  
  4610.           default:
  4611.         break;
  4612.     }
  4613. }
  4614.  
  4615. void
  4616. PauseProc()
  4617. {
  4618.     static GameMode previous_mode = PauseGame;
  4619.  
  4620.     switch (gameMode) {
  4621.           case ForceMoves:
  4622.           case EndOfGame:
  4623.           case SetupPosition:
  4624.           case EditPosition:
  4625.           default:
  4626.         return;
  4627.           case PauseGame:
  4628.         gameMode = previous_mode;
  4629.         ModeHighlight();
  4630.         previous_mode = PauseGame;
  4631.         DisplayClocks(StartTimers);
  4632.         DisplayMessage("");
  4633.         break;
  4634.           case PlayFromGameFile:
  4635.         if (readGameXID == 0) {
  4636.             readGameXID =
  4637.               XtAppAddTimeOut(appContext,
  4638.                 (int) (1000 * appData.timeDelay),
  4639.                 (XtTimerCallbackProc) ReadGameFile, NULL);
  4640.         } else {
  4641.             XtRemoveTimeOut(readGameXID);
  4642.             readGameXID = 0;
  4643.         }
  4644.         DisplayMessage("Pausing");
  4645.         break;
  4646.           case BeginningOfGame:
  4647.           case MachinePlaysBlack:
  4648.           case MachinePlaysWhite:
  4649.           case TwoMachinesPlay:
  4650.         if (currentMove == 0)    /* don't pause if no one has moved */
  4651.             return;
  4652.         previous_mode = gameMode;
  4653.         gameMode = PauseGame;
  4654.         ModeHighlight();
  4655.         DisplayClocks(StopTimers);
  4656.         DisplayMessage("Pausing");
  4657.         break;
  4658.     }
  4659. }
  4660.  
  4661. void
  4662. GameProc()
  4663. {
  4664.     if (gameMode != BeginningOfGame) {
  4665.         DisplayMessage("Press Reset first");
  4666.         return;
  4667.     }
  4668.     if (appData.loadGameFile == NULL)
  4669.         FileNamePopUp("Game file name?",
  4670.                   VOID_PROC PlayFromGameFileProc);
  4671.     else
  4672.         (void) PlayFromGameFileProc(appData.loadGameFile);
  4673. }
  4674.  
  4675. void
  4676. Iconify()
  4677. {
  4678.     Arg args[1];
  4679.  
  4680.  
  4681.     fromX = fromY = -1;
  4682.  
  4683.     XtSetArg(args[0], XtNiconic, True);
  4684.     XtSetValues(shellWidget, args, 1);
  4685. }
  4686.  
  4687. void
  4688. SendToProgram(message, fp)
  4689.     char *message;
  4690.     FILE *fp;
  4691. {
  4692.     if (fp == NULL) return;
  4693.     lastMsgFP = fp;
  4694.  
  4695.     if (xshogiDebug)
  4696.         fprintf(stderr, "Sending to %s: %s\n",
  4697.             fp == toFirstProgFP ? "first" : "second", message);
  4698.  
  4699.     if (message[strlen(message) - 1] != '\n')
  4700.         fprintf(fp, "\n%s\n", message);
  4701.     else
  4702.         fputs(message, fp);
  4703.     fflush(fp);
  4704. }
  4705.  
  4706. void
  4707. ReceiveFromProgram(fp, source, id)
  4708.     FILE *fp;
  4709.         int *source;
  4710.         XtInputId *id;
  4711. {
  4712.     char message[MSG_SIZ], *end_str;
  4713.  
  4714.     if (fgets(message, MSG_SIZ, fp) == NULL) {
  4715.         sprintf(message,
  4716.             "%s chess program (%s) exited unexpectedly",
  4717.             fp == fromFirstProgFP ? "first" : "second",
  4718.             fp == fromFirstProgFP ? appData.firstChessProgram
  4719.                 : appData.secondChessProgram);
  4720.         fprintf(stderr, "%s: %s\n", programName, message);
  4721.         ShutdownChessPrograms(message);
  4722.         return;
  4723.     }
  4724.  
  4725.     if ((end_str = (char *) strchr(message, '\r')) != NULL)
  4726.         *end_str = '\0';
  4727.     if ((end_str = (char *) strchr(message, '\n')) != NULL)
  4728.         *end_str = '\0';
  4729.  
  4730.     if (xshogiDebug)
  4731.         fprintf(stderr, "Received from %s: %s\n",
  4732.             fp == fromFirstProgFP ? "first" : "second", message);
  4733.     HandleMachineMove(message, fp);
  4734. }
  4735.  
  4736. void
  4737. SendSearchDepth(fp)
  4738.     FILE *fp;
  4739. {
  4740.     char message[MSG_SIZ];
  4741.  
  4742.     if (appData.searchDepth <= 0) return;
  4743.  
  4744.     sprintf(message, "depth\n%d\nhelp\n", appData.searchDepth);
  4745.       /* note kludge: "help" command forces gnuchessx to print
  4746.          out something that ends with a newline. */
  4747.     SendToProgram(message, fp);
  4748. }
  4749.  
  4750. void
  4751. DisplayMessage(message)
  4752.     char *message;
  4753. {
  4754.     Arg arg;
  4755.  
  4756.     XtSetArg(arg, XtNlabel, message);
  4757.     XtSetValues(messageWidget, &arg, 1);
  4758. }
  4759.  
  4760. void
  4761. DisplayName(name)
  4762.     char *name;
  4763. {
  4764.     Arg arg;
  4765.  
  4766.     XtSetArg(arg, XtNlabel, name);
  4767.     XtSetValues(nameWidget, &arg, 1);
  4768. }
  4769.  
  4770. /*
  4771.  * This routine sends a SIGINT (^C interrupt) to gnuchess to awaken it
  4772.  * if it might be busy thinking on our time.  This normally isn't needed,
  4773.  * but is useful on systems where the FIONREAD ioctl doesn't work (such 
  4774.  * as ESIX), since on those systems the gnuchess feature that lets you 
  4775.  * interrupt its thinking just by typing a command does not work.
  4776.  *
  4777.  * In the future, similar code could be used to stop gnuchess and make
  4778.  * it move immediately when it is thinking about its own move; this could
  4779.  * be useful if we want to make Backward or ForceMoves work while gnuchess
  4780.  * is thinking. --t.mann
  4781.  */
  4782. void
  4783. Attention(pid)
  4784.      int pid;
  4785. {
  4786. #if defined(ATTENTION) || defined(ESIX) || !defined(FIONREAD)
  4787.     if (appData.noChessProgram || (pid == 0)) return;
  4788.     switch (gameMode) {
  4789.           case MachinePlaysBlack:
  4790.           case MachinePlaysWhite:
  4791.           case TwoMachinesPlay:
  4792.         if (currentMove > (whitePlaysFirst ? 2 : 1) && maybeThinking) {
  4793.             if (xshogiDebug)
  4794.               fprintf(stderr, "Sending SIGINT to %s\n",
  4795.                 pid == firstProgramPID ? "first" : "second");
  4796.  
  4797.             (void) kill(pid, SIGINT); /* stop it thinking */
  4798.         }
  4799.         break;
  4800.     }
  4801. #endif /*ATTENTION*/
  4802. }
  4803.  
  4804. void
  4805. CheckFlags()
  4806. {
  4807.     if (blackTimeRemaining <= 0) {
  4808.         blackTimeRemaining = 0;
  4809.         if (!blackFlag) {
  4810.             blackFlag = True;
  4811.             if (whiteFlag)
  4812.               DisplayName("  Both flags have fallen");
  4813.             else
  4814.               DisplayName("  Black's flag has fallen");
  4815.         }
  4816.     }
  4817.     if (whiteTimeRemaining <= 0) {
  4818.         whiteTimeRemaining = 0;
  4819.         if (!whiteFlag) {
  4820.             whiteFlag = True;
  4821.             if (blackFlag)
  4822.               DisplayName("  Both flags have fallen");
  4823.             else
  4824.               DisplayName("  White's flag has fallen");
  4825.         }
  4826.     }
  4827. }
  4828.  
  4829. void
  4830. CheckTimeControl()
  4831. {
  4832.     if (!appData.clockMode) return;
  4833.     if (currentMove == 0) return;
  4834.     /*
  4835.      * add time to clocks when time control is achieved
  4836.      */
  4837.     if ((currentMove % (appData.movesPerSession * 2)) == 0) {
  4838.  
  4839.         if (blackTimeRemaining > 0)
  4840.         blackTimeRemaining += timeControl;
  4841.  
  4842.         if (whiteTimeRemaining > 0)
  4843.         whiteTimeRemaining += timeControl;
  4844.     }
  4845. }
  4846.  
  4847. void
  4848. DisplayLabels()
  4849. {
  4850.     DisplayTimerLabel(blackTimerWidget, "Black",
  4851.               blackTimeRemaining);
  4852.     DisplayTimerLabel(whiteTimerWidget, "White",
  4853.               whiteTimeRemaining);
  4854. }
  4855.  
  4856. #ifdef HAS_GETTIMEOFDAY
  4857. static struct timeval tickStartTV;
  4858. static int tickLength;
  4859.  
  4860. int
  4861. PartialTickLength()
  4862. {
  4863.     struct timeval tv;
  4864.     struct timezone tz;
  4865.     int ptl;
  4866.  
  4867.     gettimeofday(&tv, &tz);
  4868.     ptl = ( (tv.tv_sec - tickStartTV.tv_sec)*1000000 +
  4869.             (tv.tv_usec - tickStartTV.tv_usec) + 500 ) / 1000;
  4870.     if (ptl > tickLength) ptl = tickLength;
  4871.     return ptl;
  4872. }
  4873. #else /*!HAS_GETTIMEOFDAY*/
  4874. #define tickLength 1000
  4875. #endif /*HAS_GETTIMEOFDAY*/
  4876.  
  4877. /*
  4878.  * DisplayClocks manages the game clocks.
  4879.  *
  4880.  * In tournament play, white starts the clock and then black makes a move.
  4881.  * We give the human user a slight advantage if he is playing black---the
  4882.  * clocks don't run until he makes his first move, so it takes zero time.
  4883.  * Also, DisplayClocks doesn't account for network lag so it could get
  4884.  * out of sync with GNU Shogi's clock -- but then, referees are always right.
  4885.  */
  4886. void
  4887. DisplayClocks(clock_mode)
  4888.     int clock_mode;
  4889. {
  4890. #ifdef HAS_GETTIMEOFDAY
  4891.     struct timezone tz;
  4892. #endif /*HAS_GETTIMEOFDAY*/
  4893.     long timeRemaining;
  4894.  
  4895.     switch (clock_mode) {
  4896.           case ResetTimers:
  4897.         /* Stop clocks and reset to a fresh time control */
  4898.         if (timerXID != 0) {
  4899.             XtRemoveTimeOut(timerXID);
  4900.             timerXID = 0;
  4901.         }
  4902.         blackTimeRemaining = timeControl;
  4903.         whiteTimeRemaining = timeControl;
  4904.         if (blackFlag || whiteFlag) {
  4905.             DisplayName("");
  4906.             blackFlag = whiteFlag = False;
  4907.         }
  4908.         DisplayLabels();
  4909.         break;
  4910.  
  4911.           case DecrementTimers:
  4912.         /* Decrement running clock to next 1-second boundary */
  4913.         if (gameMode == PauseGame) return;
  4914.         if (!appData.clockMode) return;
  4915.  
  4916.         if (BLACK_ON_MOVE) 
  4917.           timeRemaining = blackTimeRemaining -= tickLength;
  4918.         else 
  4919.           timeRemaining = whiteTimeRemaining -= tickLength;
  4920.  
  4921.         CheckFlags();
  4922.         DisplayLabels();
  4923.         if (timeRemaining == 0) return;
  4924.  
  4925. #ifdef HAS_GETTIMEOFDAY
  4926.         tickLength = (timeRemaining <= 1000) ? 100 : 1000;
  4927.         gettimeofday(&tickStartTV, &tz);
  4928. #endif /*HAS_GETTIMEOFDAY*/
  4929.         timerXID =
  4930.           XtAppAddTimeOut(appContext, tickLength,
  4931.             (XtTimerCallbackProc) DisplayClocks,
  4932.             (XtPointer) DecrementTimers);
  4933.         break;
  4934.  
  4935.           case SwitchTimers:
  4936.         /* A player has just moved, so stop the previously running
  4937.            clock and start the other one. */
  4938.         if (timerXID != 0) {
  4939.             XtRemoveTimeOut(timerXID);
  4940.             timerXID = 0;
  4941. #ifdef HAS_GETTIMEOFDAY
  4942.             if (appData.clockMode) {
  4943.                 if (BLACK_ON_MOVE)
  4944.                   whiteTimeRemaining -= PartialTickLength();
  4945.                 else
  4946.                   blackTimeRemaining -= PartialTickLength();
  4947.                 CheckFlags();
  4948.             }
  4949. #endif /*HAS_GETTIMEOFDAY*/
  4950.         }
  4951.  
  4952.         CheckTimeControl();
  4953.         DisplayLabels();
  4954.         if (!appData.clockMode) return;
  4955.  
  4956.         timeRemaining = BLACK_ON_MOVE ?
  4957.           blackTimeRemaining : whiteTimeRemaining;
  4958.         if (timeRemaining == 0) return;
  4959. #ifdef HAS_GETTIMEOFDAY
  4960.         tickLength = (timeRemaining <= 1000) ?
  4961.           ((timeRemaining-1) % 100) + 1 :
  4962.           ((timeRemaining-1) % 1000) + 1;
  4963.         gettimeofday(&tickStartTV, &tz);
  4964. #endif /*HAS_GETTIMEOFDAY*/
  4965.         timerXID =
  4966.           XtAppAddTimeOut(appContext, tickLength,
  4967.             (XtTimerCallbackProc) DisplayClocks,
  4968.             (XtPointer) DecrementTimers);
  4969.         break;
  4970.  
  4971.           case ReDisplayTimers:
  4972.         /* Display current clock values */
  4973.         DisplayLabels();
  4974.         break;
  4975.  
  4976.           case StopTimers:
  4977.         /* Stop both clocks */
  4978.         if (timerXID == 0)
  4979.             return;
  4980.         XtRemoveTimeOut(timerXID);
  4981.         timerXID = 0;
  4982.         if (!appData.clockMode) return;
  4983. #ifdef HAS_GETTIMEOFDAY
  4984.         if (BLACK_ON_MOVE)
  4985.           whiteTimeRemaining -= PartialTickLength();
  4986.         else
  4987.           blackTimeRemaining -= PartialTickLength();
  4988.         CheckFlags();
  4989.         DisplayLabels();
  4990. #endif /*HAS_GETTIMEOFDAY*/
  4991.         break;
  4992.  
  4993.           case StartTimers:
  4994.         /* Start clock of player on move, if not already running. */
  4995.         if (timerXID != 0)
  4996.             return;
  4997.  
  4998.         DisplayLabels();
  4999.         if (!appData.clockMode) return;
  5000.  
  5001.         timeRemaining = BLACK_ON_MOVE ?
  5002.           blackTimeRemaining : whiteTimeRemaining;
  5003.         if (timeRemaining == 0) return;
  5004. #ifdef HAS_GETTIMEOFDAY
  5005.         tickLength = (timeRemaining <= 1000) ?
  5006.           ((timeRemaining-1) % 100) + 1 :
  5007.           ((timeRemaining-1) % 1000) + 1;
  5008.         gettimeofday(&tickStartTV, &tz);
  5009. #endif /*HAS_GETTIMEOFDAY*/
  5010.         timerXID =
  5011.           XtAppAddTimeOut(appContext, tickLength,
  5012.             (XtTimerCallbackProc) DisplayClocks,
  5013.             (XtPointer)DecrementTimers);
  5014.         break;
  5015.     }
  5016. }
  5017.  
  5018. void
  5019. DisplayTimerLabel(w, color, timer)
  5020.     Widget w;
  5021.     char *color;
  5022.     long timer;
  5023. {
  5024.     char buf[MSG_SIZ];
  5025.     Arg args[3];
  5026.  
  5027.     if (appData.clockMode) {
  5028.         sprintf(buf, "%s: %s", color, TimeString(timer));
  5029.         XtSetArg(args[0], XtNlabel, buf);
  5030.     } else
  5031.         XtSetArg(args[0], XtNlabel, color);
  5032.  
  5033.     if (((color[0] == 'W') && BLACK_ON_MOVE)
  5034.         || ((color[0] == 'B') && !BLACK_ON_MOVE)) {
  5035.         XtSetArg(args[1], XtNbackground, timerForegroundPixel);
  5036.         XtSetArg(args[2], XtNforeground, timerBackgroundPixel);
  5037.     } else {
  5038.         XtSetArg(args[1], XtNbackground, timerBackgroundPixel);
  5039.         XtSetArg(args[2], XtNforeground, timerForegroundPixel);
  5040.     }
  5041.  
  5042.     XtSetValues(w, args, 3);
  5043. }
  5044.  
  5045. char *
  5046. TimeString(tm)
  5047.     long tm;
  5048. {
  5049.     int second, minute, hour, day;
  5050.     static char buf[32];
  5051.  
  5052.     if (tm > 0 && tm <= 900) {
  5053.         /* convert milliseconds to tenths, rounding up */
  5054.         sprintf(buf, " 0.%1d ", (tm+99)/100);
  5055.         return buf;
  5056.     }
  5057.  
  5058.     /* convert milliseconds to seconds, rounding up */
  5059.     tm = (tm + 999) / 1000; 
  5060.  
  5061.     if (tm >= (60 * 60 * 24)) {
  5062.         day = (int) (tm / (60 * 60 * 24));
  5063.         tm -= day * 60 * 60 * 24;
  5064.     } else
  5065.         day = 0;
  5066.  
  5067.     if (tm >= (60 * 60)) {
  5068.         hour = (int) (tm / (60 * 60));
  5069.         tm -= hour * 60 * 60;
  5070.     } else
  5071.         hour = 0;
  5072.  
  5073.     if (tm >= 60) {
  5074.         minute = (int) (tm / 60);
  5075.         tm -= minute * 60;
  5076.     } else
  5077.         minute = 0;
  5078.  
  5079.     second = tm % 60;
  5080.  
  5081.     if (day > 0)
  5082.         sprintf(buf, " %d:%02d:%02d:%02d ", day, hour, minute, second);
  5083.     else if (hour > 0)
  5084.         sprintf(buf, " %d:%02d:%02d ", hour, minute, second);
  5085.     else
  5086.         sprintf(buf, " %2d:%02d ", minute, second);
  5087.  
  5088.     return buf;
  5089. }
  5090.  
  5091. void
  5092. Usage()
  5093. {
  5094.     fprintf(stderr, "Usage: %s\n", programName);
  5095.     fprintf(stderr, "\tstandard Xt options\n");
  5096.     fprintf(stderr, "\t-iconic\n");
  5097.     fprintf(stderr, "\t-tc or -timeControl minutes[:seconds]\n");
  5098.     fprintf(stderr, "\t-mps or -movesPerSession moves\n");
  5099.     fprintf(stderr, "\t-st or -searchTime minutes[:seconds]\n");
  5100.     fprintf(stderr, "\t-sd or -searchDepth number\n");
  5101.     fprintf(stderr, "\t-clock or -clockMode (True | False)\n");
  5102.     fprintf(stderr, "\t-td or -timeDelay seconds\n");
  5103.     fprintf(stderr, "\t-ncp or -noChessProgram (True | False)\n");
  5104.     fprintf(stderr, "\t-fcp or -firstChessProgram program_name\n");
  5105.     fprintf(stderr, "\t-scp or -secondChessProgram program_name\n");
  5106.     fprintf(stderr, "\t-fh or -firstHost host_name\n");
  5107.     fprintf(stderr, "\t-sh or -secondHost host_name\n");
  5108.     fprintf(stderr, "\t-rsh or -remoteShell shell_name\n");
  5109.     fprintf(stderr,
  5110.         "\t-mm or -matchMode (False | Init | Position | Opening)\n");
  5111.     fprintf(stderr, "\t-lgf or -loadGameFile file_name\n");
  5112.     fprintf(stderr, "\t-lpf or -loadPositionFile file_name\n");
  5113.     fprintf(stderr, "\t-sgf or -saveGameFile file_name\n");
  5114.     fprintf(stderr, "\t-spf or -savePositionFile file_name\n");
  5115.     fprintf(stderr, "\t-size or -boardSize (Large | Medium | Small)\n");
  5116.     fprintf(stderr, "\t-coords or -showCoords (True | False)\n");
  5117.     fprintf(stderr, "\t-mono or -monoMode (True | False)\n");
  5118.     fprintf(stderr, "\t-wpc or -blackPieceColor color\n");
  5119.     fprintf(stderr, "\t-bpc or -whitePieceColor color\n");
  5120.     fprintf(stderr, "\t-lsc or -lightSquareColor color\n");
  5121.     fprintf(stderr, "\t-dsc or -darkSquareColor color\n");
  5122.     fprintf(stderr, "\t-debug or -debugMode (True | False)\n");
  5123.     exit(2);
  5124. }
  5125.  
  5126. /*
  5127.  * This is necessary because some C libraries aren't ANSI C compliant yet.
  5128.  */
  5129. char *
  5130. StrStr(string, match)
  5131.     char *string, *match;
  5132. {
  5133.     int i, length;
  5134.  
  5135.     length = strlen(match);
  5136.  
  5137.     for (i = strlen(string) - length; i >= 0; i--, string++)
  5138.         if (!strncmp(match, string, (size_t) length))
  5139.             return string;
  5140.  
  5141.     return NULL;
  5142. }
  5143.  
  5144. int
  5145. StrCaseCmp(s1, s2)
  5146.      char *s1, *s2;
  5147. {
  5148.     char c1, c2;
  5149.  
  5150.     for (;;) {
  5151.         c1 = ToLower(*s1++);
  5152.         c2 = ToLower(*s2++);
  5153.         if (c1 > c2) return 1;
  5154.         if (c1 < c2) return -1;
  5155.         if (c1 == '\000') return 0;
  5156.     }
  5157. }
  5158.  
  5159.  
  5160. int
  5161. ToLower(c)
  5162.      int c;
  5163. {
  5164.     return isupper(c) ? tolower(c) : c;
  5165. }
  5166.  
  5167.  
  5168. int
  5169. ToUpper(c)
  5170.      int c;
  5171. {
  5172.     return islower(c) ? toupper(c) : c;
  5173. }
  5174.  
  5175.  
  5176. #if    SYSTEM_FIVE || SYSV
  5177. #ifdef    IRIX /*??*/
  5178. char *
  5179. PseudoTTY(ptyv)
  5180.     int *ptyv;
  5181.      {
  5182.          char *line;
  5183.  
  5184.          line = (char *)_getpty(ptyv, O_RDWR, 0600, 0);
  5185.          if (0 == line)
  5186.              return NULL;
  5187.          return line;
  5188.      }
  5189. #else    /*!IRIX*/
  5190. char *
  5191. PseudoTTY(ptyv)
  5192.     int *ptyv;
  5193. {
  5194. #if    SVR4
  5195.     char *ptsname(), *ptss;
  5196.  
  5197.     *ptyv = open("/dev/ptmx", O_RDWR);
  5198.     if (*ptyv > 0 ) {
  5199.         if (grantpt(*ptyv) == -1)
  5200.             return NULL;
  5201.         if (unlockpt(*ptyv) == -1)
  5202.             return NULL;
  5203.         if (!(ptss = ptsname(*ptyv)))
  5204.             return NULL;
  5205.         strncpy(ptyname, ptss, sizeof(ptyname));
  5206.         ptyname[sizeof(ptyname) -1] = 0;
  5207.         return ptyname;
  5208.     }
  5209.     
  5210. #else    /* !SVR4 */
  5211.     struct stat stb;
  5212.     int c, i;
  5213.  
  5214.     for (c = 'p'; c <= 'z'; c++)
  5215. #if    defined(HPUX) || defined(hpux)
  5216.         for (i = 0; i < 15 /*??*/; i++) {
  5217.             sprintf(ptyname, "/dev/ptym/pty%c%x", c, i);
  5218. #else /* !HPUX */
  5219.         for (i = 0; i < 16; i++) {
  5220. #ifdef    RTU
  5221.             sprintf(ptyname, "/dev/pty%x", i);
  5222. #else /* !RTU */
  5223.             sprintf(ptyname, "/dev/pty%c%x", c, i);
  5224. #endif /* RTU */
  5225. #endif /* HPUX */
  5226.  
  5227. #ifdef    IRIS
  5228.             *ptyv = open("/dev/ptc", O_RDWR, 0);
  5229.             if (*ptyv < 0)
  5230.                 return NULL;
  5231.             if (fstat(*ptyv, &stb) < 0)
  5232.                 return NULL;
  5233. #else /* !IRIS */
  5234.             if (stat(ptyname, &stb) < 0)
  5235.                 return NULL;
  5236.             *ptyv = open(ptyname, O_RDWR, 0);
  5237. #endif /* IRIS */
  5238.  
  5239.             if (*ptyv >= 0) {
  5240. #if    defined(HPUX) || defined(hpux)
  5241.                 sprintf(ptyname, "/dev/pty/tty%c%x", c, i);
  5242. #else /* !HPUX */
  5243. #ifdef    RTU
  5244.                 sprintf(ptyname, "/dev/ttyp%x", i);
  5245. #else /* !RTU */
  5246. #ifdef    IRIS
  5247.                 sprintf(ptyname, "/dev/ttyq%d",
  5248.                     minor(stb.st_rdev));
  5249. #else /* !IRIS, !RTU, !HPUX */
  5250.                 sprintf(ptyname, "/dev/tty%c%x", c, i);
  5251. #endif /* IRIS */
  5252. #endif /* RTU */
  5253. #endif /* HPUX */
  5254.  
  5255. #ifndef    UNIPLUS
  5256.                 if (access(ptyname, 6) != 0) {
  5257.                     close(*ptyv);
  5258. #ifdef    IRIS
  5259.                     return NULL;
  5260. #else /* !IRIS */
  5261.                     continue;
  5262. #endif /* IRIS */
  5263.                 }
  5264. #endif /* !UNIPLUS */
  5265.  
  5266. #ifdef    IBMRTAIX
  5267.             signal(SIGHUP, SIG_IGN);
  5268. #endif /* IBMRTAIX */
  5269.             return ptyname;
  5270.         }
  5271.     }
  5272.  
  5273. #endif
  5274.     return NULL;
  5275. }
  5276. #endif /*IRIX*/
  5277.  
  5278. #else /* !SYSTEM_FIVE */
  5279.  
  5280. void
  5281. CatchPipeSignal(dummy)
  5282.      int dummy;
  5283. {
  5284.     char message[MSG_SIZ];
  5285.  
  5286.     sprintf(message,
  5287.         "%s chess program (%s) exited unexpectedly",
  5288.         lastMsgFP == toFirstProgFP ? "first" : "second",
  5289.         lastMsgFP == toFirstProgFP ? appData.firstChessProgram
  5290.             : appData.secondChessProgram);
  5291.     fprintf(stderr, "%s: %s\n", programName, message);
  5292.     ShutdownChessPrograms(message);
  5293.     return;
  5294. }
  5295. #endif
  5296.